diff --git a/Programs/CosmOS/README.md b/Programs/CosmOS/README.md
index 1b0373c..15a917e 100644
--- a/Programs/CosmOS/README.md
+++ b/Programs/CosmOS/README.md
@@ -116,6 +116,56 @@ an installed library and a copy of the source.
 The disk is rebuilt from scratch when its applications change, so its contents describe
 the current source tree rather than accumulating files left by older builds.
 
+## Scripts:
+
+`do <file>` runs the lines in a file as though somebody had typed them. Every command works
+the same way it does at the prompt, because the only thing a script changes is where the next
+line comes from - the shell splits it, matches it and runs it without knowing the difference.
+
+```
+#! script
+; Build the system and put it where the machine will find it.
+cd /Source/CosmOS
+Asm cosmos.asm
+```
+
+**The first two bytes must be `#!`**, or the shell refuses the file and says so. That is what
+tells a script from anything else, and it is deliberately not the name and not a flag in the
+directory entry: the rule this filesystem keeps is that an entry holds only what the content
+cannot say about itself, and a script can say what it is. The loader already refuses anything
+that does not begin `SBEX`, so the two kinds of runnable file turn each other away without
+either of them having been told about the other.
+
+What follows the `#!` is ignored. It is where the name of an interpreter goes if there is ever
+a second one; today there is one and it is this shell.
+
+**`#` is a directive and `;` is a comment, exactly as in SplitBit assembly.** One rule across
+the machine rather than two dialects: `#` means this line is about the file, `;` means ignore
+this line. Comments and blank lines never reach the shell at all - they are dropped by the
+reader, so they are not echoed and the dispatch never sees a line it would have to know to
+ignore. This is not Unix's convention and is not trying to be; there `#!` genuinely is a
+comment that only the kernel looks at, while here the shell requires it.
+
+**Each line is echoed as it runs**, after the prompt, so that a script reads exactly like
+somebody typing it and a script that stops says where.
+
+**A script stops at the first line that does not work.** A build whose first step failed and
+whose second step ran anyway produces something wrong and reports success, which is the whole
+reason the shell now remembers whether a line worked. What counts as not working is a command
+that failed, a name the shell does not know, or a program that exited with a status. Nothing
+is printed but `stopped: that line did not work` - whatever failed has already said what was
+wrong in words.
+
+**A script running out is not the same as typing running out.** The console ending means
+there is nobody there and the shell stops; a script ending means go back to whoever asked for
+it, so the next line comes from the console again.
+
+The interactive assembler reads its lines the same way, so a script can contain a block of
+assembly and end it with a `.` just as you would by hand.
+
+**A script cannot yet run another script.** That is the next thing, and it wants a stack of
+positions rather than the single one the reader keeps today.
+
 ## Shell Commands:
 
 CosmOS currently provides these built-in commands:
@@ -125,6 +175,7 @@ CosmOS currently provides these built-in commands:
 | `dir` | List the files on the mounted disk and their sizes. |
 | `load <path>` | Read and validate an SBEX application, then place its code and data where its header requests. |
 | `run [words]` | Start the loaded application and make the rest of the line available to it as an argument. |
+| `do <script>` | Run the lines in a file as though they had been typed. See Scripts. |
 | `cd [path]` | Go to a directory, or to the root with nothing after it. |
 | `mkdir <path>` | Make a directory. |
 | `rmdir <path>` | Remove one, if it is empty. |
diff --git a/Programs/CosmOS/Source/cosmos.asm b/Programs/CosmOS/Source/cosmos.asm
index 02d2cb3..8746e00 100644
--- a/Programs/CosmOS/Source/cosmos.asm
+++ b/Programs/CosmOS/Source/cosmos.asm
@@ -47,6 +47,7 @@
 #Include text.asm
 #Include sbfs.asm
 #Include services.asm
+#Include script.asm
 
 #Program
 
@@ -133,6 +134,24 @@ bootNoDisk:
 ; shell. Only saying so leaves the monitor, or a program breaking the machine badly enough
 ; to need starting again.
 prompt:
+  ; ---- A script stops at the first line that did not work ----
+  ;
+  ; Checked here, before the next line is read, because this is the one place every command
+  ; comes back to. A build whose first step failed and whose second step ran anyway produces
+  ; something wrong and says it succeeded, which is the failure this whole flag exists to
+  ; prevent.
+  SETD.1 ScriptRunning
+  LDA.1
+  BRA promptWhere
+  SETD.1 LineFailed
+  LDA.1
+  BRA promptWhere
+  SETD.0 ScriptStopped
+  CALL printString
+  CALL newLine
+  CALL scriptClose
+
+promptWhere:
   ; Where you are, but only when that is not obvious. At the root the prompt is the one it
   ; has always been, so a machine nobody has moved about on looks exactly as it did - and
   ; every recorded test that never says "cd" keeps its recorded prompt.
@@ -160,7 +179,7 @@ promptSay:
 
   SETD.0 CommandLine
   INIB 0d63
-  CALL readLine
+  CALL shellReadLine
 
   ; Running out of typing is how this ends. It is not the same as an empty line, which is
   ; just somebody pressing return, and the shell should sit there when that happens.
@@ -230,6 +249,11 @@ promptSay:
   CALL textSame
   BRQ doRename
 
+  SETD.0 CommandLine
+  SETD.1 DoName
+  CALL textSame
+  BRQ doScript
+
   SETD.0 CommandLine
   SETD.1 HelpName
   CALL textSame
@@ -282,6 +306,31 @@ promptSay:
   CALL textSame
   BRQ doAssemble
 
+; ---- Where a line comes from ----
+;
+; The whole of what a script is. Everything below this - splitting the line, matching it
+; against the commands, loading a program - cannot tell the difference and does not have to.
+;
+; A SCRIPT RUNNING OUT IS NOT THE SAME AS TYPING RUNNING OUT. The console ending means there
+; is nobody there and the shell should stop; a script ending means go back to whoever asked
+; for it. So the end of a script falls through to the console rather than to the door.
+shellReadLine:
+  SETD.1 ScriptRunning
+  LDA.1
+  BRA shellReadTyped
+  CALL scriptLine
+  BNQ shellReadTyped
+
+  ; Echoed, so that a script working can be watched and a script failing says where. It is
+  ; printed after the prompt, so it reads exactly like somebody typing it.
+  CALL printString
+  CALL newLine
+  RET
+
+shellReadTyped:
+  CALL readLine
+  RET
+
 ; ---- A command that did not work ----
 ;
 ; The one place a failure is recorded, so that the thing reading lines out of a file can
@@ -1531,6 +1580,37 @@ fileComplain:
   CALL newLine
   BRI commandFailed
 
+; ---- do ----
+;
+; Runs the lines in a file as though they had been typed. What makes a file one of these is
+; the #! on the front of it, not its name and not a flag in its directory entry: the rule is
+; that the entry holds only what the content cannot say about itself, and a script can say
+; what it is. The loader already refuses anything that is not SBEX, so the two kinds of
+; runnable thing turn each other away without either of them knowing about the other.
+doScript:
+  SETD.1 TextRest
+  LDD.0.1
+  LDA.0
+  BRA scriptNoName
+
+  CALL scriptOpen
+  BRQ prompt                ; It is open, and the next line read will come from it.
+
+  ; Which of the two went wrong. A number would be no use to anybody here.
+  MVQA
+  INIB 0x01
+  CCF
+  SUB
+  BRQ scriptNoFile
+  SETD.0 ScriptNotOne
+  BRI fileComplain
+scriptNoFile:
+  SETD.0 ScriptNoFile
+  BRI fileComplain
+scriptNoName:
+  SETD.0 ScriptUsage
+  BRI fileComplain
+
 ; ---- run ----
 ;
 ; Hands the machine to whatever was loaded. Where the Stack is now is written down first,
@@ -3094,7 +3174,7 @@ assembleLine:
 
   SETD.0 AsmLine
   INIB 0d40
-  CALL readLine
+  CALL shellReadLine
 
   INA 0x01
   INIB 0x02                 ; ENDED, so there is nothing more to assemble.
@@ -3517,6 +3597,14 @@ OnFallback:
 "
 NoDisk:
 "no filesystem on the disk"
+ScriptUsage:
+"do: give me the name of a script"
+ScriptNoFile:
+"do: cannot find it"
+ScriptNotOne:
+"do: that is not a script - it wants #! on the first line"
+ScriptStopped:
+"stopped: that line did not work"
 Unknown:
 "I do not know: "
 Farewell:
@@ -3696,6 +3784,8 @@ NeedsValue:
 "that one needs a value after it"
 DirName:
 "dir"
+DoName:
+"do"
 LoadName:
 "load"
 RunName:
diff --git a/Programs/CosmOS/Source/script.asm b/Programs/CosmOS/Source/script.asm
new file mode 100644
index 0000000..1d0b1e1
--- /dev/null
+++ b/Programs/CosmOS/Source/script.asm
@@ -0,0 +1,352 @@
+; Reading shell lines out of a file.
+;
+;   DP0 = the file's name
+;   CALL scriptOpen           Q = 0 and a script is running, or Q says what was wrong:
+;                               1 there is no such file
+;                               2 it is not a script - no #! on the front
+;   DP0 = a buffer, B = how much room
+;   CALL scriptLine           Q = 0 and there is a line in the buffer, or nonzero at the end
+;
+; Written by Anachronaut
+;
+; ---- Why the shell reads files and not the other way round ----
+;
+; fileStream.asm does almost this and is deliberately not used. It is application machinery:
+; More, Type and Wander each include it and each get their own copy in their own Data
+; Segment. The shell reading a script through it would be a fourth copy, and the shell is the
+; one place where that copy has to survive running a program - which is exactly the thing
+; those programs are. Here the state belongs to the system and nothing a program does can
+; reach it.
+;
+; ---- A block, and a nought on the end of it ----
+;
+; The reader walks a Data Pointer along the block and stops at a nought. A block is 256 bytes
+; and a count of them does not fit in a byte, so every other way of knowing where the block
+; ends costs sixteen bit arithmetic on every character. Writing a nought after the last byte
+; costs one store per block and turns the whole question into "is this byte zero".
+;
+; The buffer is 257 bytes for that reason: a full block leaves the nought at the end of it.
+; A script cannot contain a nought, which is not a restriction anybody will notice - it is
+; text, and the #! on the front is what stops a program being read as one.
+
+#Program
+
+; ---- Opening ----
+;
+; The name is COPIED rather than remembered by address. osFileBlock is given the name again
+; for every block, and the caller's copy is CommandLine, which the next line typed will
+; overwrite. fileStream remembers an address and says in its own comment that the address
+; must stay valid; here it cannot, because the thing that reads the next line is the reason
+; the name is needed.
+scriptOpen:
+  SETD.1 ScriptName
+  INIB 0d63
+  CALL copyText
+
+  SETD.0 ScriptName
+  SWI osFileInfo
+  BRQ scriptOpenThere
+  INIA 0x01
+  BRI scriptOpenFailed
+scriptOpenThere:
+  ; DP3 is how many blocks. A file of none is not a script.
+  PSHD.3
+  POPB
+  POPA
+  SETD.1 ScriptBlocks
+  STA.1
+  INCD.1
+  STB.1
+  OR
+  BRQ scriptOpenNotOne
+
+  SETD.1 ScriptIndex
+  RSTA
+  STA.1
+  INCD.1
+  STA.1
+
+  ; The first block, so that the #! can be looked at before anything is promised.
+  CALL scriptFill
+  BNQ scriptOpenNotOne
+
+  ; ---- What makes a file a script ----
+  ;
+  ; Two bytes, and the rest of the line ignored. A directive rather than a comment, the way
+  ; #Program is in assembly: the shell reads it and refuses the file without it, so calling
+  ; it a comment would be a lie about what it does. What follows the #! is where the name of
+  ; an interpreter goes when there is a second one; today there is one and it is this shell.
+  SETD.1 ScriptBlock
+  LDA.1
+  INIB 0d35                 ; '#'
+  CCF
+  SUB
+  BNQ scriptOpenNotOne
+  INCD.1
+  LDA.1
+  INIB 0d33                 ; '!'
+  CCF
+  SUB
+  BNQ scriptOpenNotOne
+
+  ; Past the shebang line, wherever it ends.
+  CALL scriptSkipLine
+
+  INIA 0x01
+  SETD.1 ScriptRunning
+  STA.1
+  RSTA
+  BRI scriptOpenFailed      ; A is nought, which is the answer for "it opened".
+
+scriptOpenNotOne:
+  INIA 0x02
+scriptOpenFailed:
+  ; Q is the answer, and A holds it. Adding nought is how a register becomes Q.
+  RSTB
+  CCF
+  ADD
+  RET
+
+; ---- One line ----
+;
+; Comments and blank lines never reach the shell. The reader drops them, so the echo does not
+; print them and the dispatch never sees a line it would have to know to ignore.
+scriptLine:
+  SETD.1 ScriptRoom
+  STB.1
+  SETD.1 ScriptInto
+  STD.0.1
+
+scriptLineAgain:
+  SETD.1 ScriptLength
+  RSTA
+  STA.1
+  SETD.0 ScriptInto
+  LDD.0.0
+
+scriptLineNext:
+  CALL scriptByte
+  BNQ scriptLineEnded
+
+  SETD.1 ScriptChar
+  LDA.1
+  INIB 0d10
+  CCF
+  SUB
+  BRQ scriptLineDone
+  ; A still holds the character: SUB writes Q and leaves it alone.
+  INIB 0d13                 ; Carriage return, from a file written on a host that uses them.
+  CCF
+  SUB
+  BRQ scriptLineNext
+
+  ; Room?
+  SETD.1 ScriptLength
+  LDA.1
+  SETD.1 ScriptRoom
+  LDB.1
+  CCF
+  SUB
+  BRQ scriptLineNext        ; Full. Read on and drop what comes, the way readLine does.
+
+  SETD.1 ScriptChar
+  LDA.1
+  STA.0
+  INCD.0
+  SETD.1 ScriptLength
+  LDA.1
+  INCA
+  STA.1
+  BRI scriptLineNext
+
+scriptLineDone:
+  ; Terminate it, then decide whether the shell wants to see it.
+  RSTA
+  STA.0
+
+  SETD.0 ScriptInto
+  LDD.0.0
+  LDA.0
+  BRA scriptLineAgain       ; Empty.
+  INIB 0d59                 ; ';' - a comment, the same as everywhere else on this machine.
+  CCF
+  SUB
+  BRQ scriptLineAgain
+
+  RSTA                      ; Q = 0: there is a line.
+  RSTB
+  CCF
+  ADD
+  RET
+
+scriptLineEnded:
+  ; ---- A last line with no newline on it is still a line ----
+  ;
+  ; Text files do not reliably end with one, and a script whose final command silently did
+  ; not run because somebody's editor left the newline off is a bad way to find that out.
+  ; If anything has been gathered, finish it the ordinary way; the next call comes back here
+  ; with nothing gathered and ends for real.
+  SETD.1 ScriptLength
+  LDA.1
+  BRA scriptLineNoMore
+  BRI scriptLineDone
+
+scriptLineNoMore:
+  CALL scriptClose
+  INIA 0x01
+  RSTB
+  CCF
+  ADD
+  RET
+
+; ---- One character, or the end ----
+;
+; Q = 0 and the character is in ScriptChar, or Q is one and there are no more.
+;
+; IN MEMORY RATHER THAN IN A REGISTER, because RET puts A and B back the way the caller had
+; them - only Q and Data Pointer 3 survive a CALL. Handing the character back in A looked
+; right, assembled, and returned the caller's own A every time.
+scriptByte:
+  SETD.1 ScriptAt
+  LDD.1.1
+  LDA.1
+  BRA scriptByteRefill      ; The nought at the end of the block.
+
+  ; Step the saved pointer past it.
+  SETD.1 ScriptChar
+  STA.1
+  SETD.1 ScriptAt
+  LDD.0.1
+  INCD.0
+  STD.0.1
+  RSTA
+  RSTB
+  CCF
+  ADD                       ; Q = 0.
+  RET
+
+scriptByteRefill:
+  CALL scriptFill
+  BNQ scriptByteNoMore
+  BRI scriptByte
+scriptByteNoMore:
+  INIA 0x01
+  RSTB
+  CCF
+  ADD
+  RET
+
+; ---- The next block, with a nought written after it ----
+;
+; Q = 0 if there is one.
+scriptFill:
+  SETD.1 ScriptBlocks
+  LDA.1
+  INCD.1
+  LDB.1
+  OR
+  BRQ scriptFillNoMore
+
+  SETD.0 ScriptName
+  SETD.1 ScriptBlock
+  SETD.2 ScriptIndex
+  LDA.2
+  INCD.2
+  LDB.2
+  SWI osFileBlock
+  BNQ scriptFillNoMore
+
+  ; DP3 is how many bytes came back. The nought goes after them.
+  SETD.1 ScriptBlock
+  PSHD.3
+  POPB
+  POPA
+  DPUW.1
+  RSTA
+  STA.1
+
+  SETD.1 ScriptAt
+  SETD.0 ScriptBlock
+  STD.0.1
+
+  ; Index++, blocks--.
+  SETD.1 ScriptIndex
+  INCD.1
+  LDA.1
+  INCA
+  STA.1
+  BNC scriptFillCount
+  DECD.1
+  LDA.1
+  INCA
+  STA.1
+scriptFillCount:
+  SETD.1 ScriptBlocks
+  INCD.1
+  LDA.1
+  BRA scriptFillBorrow
+  DECA
+  STA.1
+  BRI scriptFillGot
+scriptFillBorrow:
+  INIA 0xFF
+  STA.1
+  DECD.1
+  LDA.1
+  DECA
+  STA.1
+scriptFillGot:
+  RSTA
+  RSTB
+  CCF
+  ADD
+  RET
+
+scriptFillNoMore:
+  INIA 0x01
+  RSTB
+  CCF
+  ADD
+  RET
+
+; Everything up to and including the next line feed, thrown away. Used for the shebang.
+scriptSkipLine:
+  CALL scriptByte
+  BNQ scriptSkipDone
+  SETD.1 ScriptChar
+  LDA.1
+  INIB 0d10
+  CCF
+  SUB
+  BNQ scriptSkipLine
+scriptSkipDone:
+  RET
+
+scriptClose:
+  RSTA
+  SETD.1 ScriptRunning
+  STA.1
+  RET
+
+#Data
+
+ScriptRunning:
+  0x00
+ScriptName:
+  #Reserve 0d64
+ScriptBlocks:
+  0x00 0x00
+ScriptIndex:
+  0x00 0x00
+ScriptAt:
+  0x00 0x00
+ScriptInto:
+  0x00 0x00
+ScriptRoom:
+  0x00
+ScriptLength:
+  0x00
+ScriptChar:
+  0x00
+ScriptBlock:
+  #Reserve 0d257
diff --git a/SplitBit Test Manual.md b/SplitBit Test Manual.md
index f9fa5f7..49db860 100644
--- a/SplitBit Test Manual.md	
+++ b/SplitBit Test Manual.md	
@@ -79,7 +79,7 @@ from `make`, not from here.
 ### 1. Recorded output
 
 `Tests/run.sh` assembles each program named in `Tests/manifest`, runs it, and compares
-everything it printed against a file in `Tests/expected`. 171 tests, of which 109 run, 35
+everything it printed against a file in `Tests/expected`. 174 tests, of which 112 run, 35
 only assemble, 16 are expected to fail to assemble, and 11 boot from ROM with no image
 given at all.
 
diff --git a/Tests/expected/cosmosRun.out b/Tests/expected/cosmosRun.out
index c5e3c7e..1d82cea 100644
--- a/Tests/expected/cosmosRun.out
+++ b/Tests/expected/cosmosRun.out
@@ -8,7 +8,12 @@ Keys.sbx                664
 Say.sbx                 156
 Break.sbx               149
 notes.txt               21
-8 files
+hi.script               87
+bad.script              45
+plain.script            24
+cross.script            280
+nonl.script             38
+13 files
 > load what?
 > no such file
 > not a program
diff --git a/Tests/expected/cosmosScript.out b/Tests/expected/cosmosScript.out
new file mode 100644
index 0000000..447fe0f
--- /dev/null
+++ b/Tests/expected/cosmosScript.out
@@ -0,0 +1,10 @@
+CosmOS
+> > Say from a script
+it says: from a script
+finished
+> Say and again
+it says: and again
+finished
+> halted
+Execution halted.
+[exit 0]
diff --git a/Tests/expected/cosmosScriptBad.out b/Tests/expected/cosmosScriptBad.out
new file mode 100644
index 0000000..157fecf
--- /dev/null
+++ b/Tests/expected/cosmosScriptBad.out
@@ -0,0 +1,13 @@
+CosmOS
+> > Say before
+it says: before
+finished
+> nosuchcommand
+I do not know: nosuchcommand
+stopped: that line did not work
+> do: that is not a script - it wants #! on the first line
+> do: cannot find it
+> do: give me the name of a script
+> halted
+Execution halted.
+[exit 0]
diff --git a/Tests/expected/cosmosScriptEdges.out b/Tests/expected/cosmosScriptEdges.out
new file mode 100644
index 0000000..07cbf8a
--- /dev/null
+++ b/Tests/expected/cosmosScriptEdges.out
@@ -0,0 +1,10 @@
+CosmOS
+> > Say across the block boundary
+it says: across the block boundary
+finished
+> > Say with no newline after me
+it says: with no newline after me
+finished
+> halted
+Execution halted.
+[exit 0]
diff --git a/Tests/expected/cosmosSlowDisk.out b/Tests/expected/cosmosSlowDisk.out
index c74d37d..7cf8937 100644
--- a/Tests/expected/cosmosSlowDisk.out
+++ b/Tests/expected/cosmosSlowDisk.out
@@ -7,7 +7,12 @@ Keys.sbx                664
 Say.sbx                 156
 Break.sbx               149
 notes.txt               21
-8 files
+hi.script               87
+bad.script              45
+plain.script            24
+cross.script            280
+nonl.script             38
+13 files
 > loaded, starting at 4000
 > it says: the disk took its time
 finished
diff --git a/Tests/input/cosmosScript.in b/Tests/input/cosmosScript.in
new file mode 100644
index 0000000..b6c77dd
--- /dev/null
+++ b/Tests/input/cosmosScript.in
@@ -0,0 +1,2 @@
+do hi.script
+exit
diff --git a/Tests/input/cosmosScriptBad.in b/Tests/input/cosmosScriptBad.in
new file mode 100644
index 0000000..f75a956
--- /dev/null
+++ b/Tests/input/cosmosScriptBad.in
@@ -0,0 +1,5 @@
+do bad.script
+do plain.script
+do nothere.script
+do
+exit
diff --git a/Tests/input/cosmosScriptEdges.in b/Tests/input/cosmosScriptEdges.in
new file mode 100644
index 0000000..2a22179
--- /dev/null
+++ b/Tests/input/cosmosScriptEdges.in
@@ -0,0 +1,3 @@
+do cross.script
+do nonl.script
+exit
diff --git a/Tests/makedisks.sh b/Tests/makedisks.sh
index 1924b35..818aebc 100755
--- a/Tests/makedisks.sh
+++ b/Tests/makedisks.sh
@@ -109,6 +109,33 @@ for i in 1 2 3 4 5 6 7 8; do "$TOOL" put "$DISKS/sbfs.img" "filler$i.txt" >/dev/
 printf 'this is not a program' > notes.txt
 "$TOOL" put "$DISKS/cosmos.img" notes.txt >/dev/null
 
+# ---- Scripts, including the ones that are meant to go wrong ----
+#
+# Built here rather than committed, because two of them are about BYTE POSITIONS and a
+# committed file is one an editor can helpfully repair. cross.script puts a command across
+# the 256 byte boundary between two blocks, and nonl.script ends without a newline; both
+# were real faults before they were checks, and both are invisible in a text editor.
+printf '#! script\n; A comment, which never reaches the shell.\nSay from a script\n\nSay and again\n' > hi.script
+"$TOOL" put "$DISKS/cosmos.img" hi.script >/dev/null
+# Stops at the bad line, so "after" must not appear.
+printf '#! script\nSay before\nnosuchcommand\nSay after\n' > bad.script
+"$TOOL" put "$DISKS/cosmos.img" bad.script >/dev/null
+# No #! on the front, so it is a text file and not a script.
+printf 'Say this has no shebang\n' > plain.script
+"$TOOL" put "$DISKS/cosmos.img" plain.script >/dev/null
+# A command that starts in the first block and finishes in the second.
+python3 -c "
+head = '#! script\n'
+pad = ''
+while len(head) + len(pad) < 246:
+    pad += '; pad\n'
+open('cross.script','w').write(head + pad + 'Say across the block boundary\n')
+"
+"$TOOL" put "$DISKS/cosmos.img" cross.script >/dev/null
+# The last line has no newline after it and still has to run.
+printf '#! script\nSay with no newline after me' > nonl.script
+"$TOOL" put "$DISKS/cosmos.img" nonl.script >/dev/null
+
 # A disk of its own for the writing test, with one file already on it so that what it
 # writes has to be placed somewhere that does not tread on what is there.
 "$TOOL" format "$DISKS/write.img" 32 1 >/dev/null
diff --git a/Tests/manifest b/Tests/manifest
index bc83432..d2c4044 100644
--- a/Tests/manifest
+++ b/Tests/manifest
@@ -762,6 +762,19 @@ waitTest             | testPrograms/waitTest.asm          | run      | -
 # Interrupt Flag with no handler installed anywhere: a standing line faults there, which is
 # how a program loaded by CosmOS used to die on the instruction after its SIF.
 diskLineTest         | testPrograms/diskLineTest.asm      | run      | -                  | 1000000 | disks/sbfs.img
+# ---- Scripts ----
+#
+# The shell reading its lines out of a file instead of off the console. cosmosScript is the
+# ordinary case and also checks that comments and blank lines never reach the dispatch, and
+# that a script running out hands back to the console rather than ending the shell.
+cosmosScript         | CosmOS/Source/cosmos.asm           | run      | cosmosScript.in    | 200000000 | disks/cosmos.img
+# The three refusals and the stop. A line that fails stops the script - "after" must not be
+# in the recording - and a file with no #! is not a script however it is named.
+cosmosScriptBad      | CosmOS/Source/cosmos.asm           | run      | cosmosScriptBad.in | 200000000 | disks/cosmos.img
+# The two that are about byte positions rather than about behaviour: a command lying across
+# the boundary between two blocks, and a last line with no newline after it. Both of these
+# were faults before they were checks.
+cosmosScriptEdges    | CosmOS/Source/cosmos.asm           | run      | cosmosScriptEdges.in | 200000000 | disks/cosmos.img
 printDecimalTest     | testPrograms/printDecimalTest.asm  | xfail    | -                  | -
 printDigitTest       | testPrograms/printDigitTest.asm    | xfail    | -                  | -
 printHexTest         | testPrograms/printHexTest.asm      | xfail    | -                  | -
diff --git a/Tests/native.sh b/Tests/native.sh
index c9bbe58..14db73a 100755
--- a/Tests/native.sh
+++ b/Tests/native.sh
@@ -128,7 +128,14 @@ done
 # not to exercise; a binary that BUILDS ITSELF AGAIN and comes out the same has been through
 # its own machinery. The host is no longer necessary after this point - it is a convenience.
 
-SOURCES="cosmos console sbfs services text"
+# ---- Read out of cosmos.asm rather than listed here ----
+#
+# Everything the system includes has to be on the disk it is going to be assembled on. This
+# was a hand written list and went stale the moment script.asm was added: the self build
+# stopped, saying it could not find a file nobody had thought to put there. That is the
+# fourth time a list beside a thing has drifted from the thing, so it is now the thing that
+# is asked.
+SOURCES="cosmos $(sed -n 's/^#Include \(.*\)\.asm$/\1/p' "$ROOT/Programs/CosmOS/Source/cosmos.asm" | tr '\n' ' ')"
 PARTS="Asm numbers source token classify labels vectors table"
 
 "$TOOL" format "$WORK/self.img" 4096 8 >/dev/null
diff --git a/makefile b/makefile
index bb1b1a5..ee1e17d 100644
--- a/makefile
+++ b/makefile
@@ -574,7 +574,7 @@ $(COSMOS_DISK): $(APPS) $(NATIVE_ASM) $(COSMOS) $(STAGE2) \
 	@# read on the machine and not assembled on it, and the assembler said only "nothing was
 	@# written". Mirrored, so that the next one nobody thinks of is here anyway.
 	$(DISKTOOL) mirror $@ $(PROG_DIR)/Libraries /Lib
-	@for f in console fileStream sbfs services text config; do \
+	@for f in console fileStream sbfs services text config script; do \
 		$(DISKTOOL) put $@ $(PROG_DIR)/CosmOS/Source/$$f.asm /Lib/$$f.asm >/dev/null \
 			|| exit 1; done
 	@for f in classify labels numbers scratch source table token vectors; do \