Roll back partial script on substitution failure and harden test stub

Wrap the template copy, name substitution, and project registration in a
single cleanup boundary so a failure after fs.copy removes the partially
created script instead of leaving it behind and blocking a clean retry.
Make the test fixture's pathExists fake resolve by the requested path
rather than by call order, and add a regression test for the
substitution-failure rollback.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 1487b95c-ac14-455f-9b7f-9770cf65e11e

Author: StellaHuang95

src/features/creators/newScriptProject.ts

@@ -176,32 +176,37 @@ export class NewScriptProject implements PythonProjectCreator {
             );
             return undefined;
         }
-        await fs.copy(newScriptTemplateFile, scriptDestination);
-
-        // 2. Replace 'script_name' in the file using a helper (just script name remove .py)
-        await replaceInFilesAndNames(scriptDestination, 'script_name', scriptFileName.replace(/\.py$/, ''));
-
-        // Add the created script to the project manager
+        // Build the project entry up front so copying the template, substituting
+        // the script name, and registering the project share one cleanup boundary:
+        // if any step fails, the partially created script is removed so a retry
+        // starts from a clean state.
         const createdScript: PythonProject = {
             name: scriptFileName,
             uri: identityRootUri.with({
                 path: path.posix.join(identityRootUri.path, scriptFileName),
             }),
         };
+        let projectRegistrationAttempted = false;
         try {
+            await fs.copy(newScriptTemplateFile, scriptDestination);
+            // Replace 'script_name' in the file (script name without the .py suffix).
+            await replaceInFilesAndNames(scriptDestination, 'script_name', scriptFileName.replace(/\.py$/, ''));
+            projectRegistrationAttempted = true;
             await this.projectManager.add(createdScript);
-        } catch (registrationError) {
-            try {
-                this.projectManager.remove(createdScript);
-            } catch (rollbackError) {
-                traceError('Failed to remove the new script project after registration failed:', rollbackError);
+        } catch (creationError) {
+            if (projectRegistrationAttempted) {
+                try {
+                    this.projectManager.remove(createdScript);
+                } catch (rollbackError) {
+                    traceError('Failed to remove the new script project after creation failed:', rollbackError);
+                }
             }
             try {
                 await fs.remove(scriptDestination);
             } catch (rollbackError) {
-                traceError('Failed to delete the new script after registration failed:', rollbackError);
+                traceError('Failed to delete the new script after creation failed:', rollbackError);
             }
-            throw registrationError;
+            throw creationError;
         }
 
         // 3. add custom github copilot instructions

src/test/features/creators/newScriptProject.unit.test.ts

@@ -63,12 +63,17 @@ suite('new723ScriptTemplate / NewScriptProject', () => {
     });
 
     function stubSuccessfulFileCreation() {
+        const templateFile = path.resolve(
+            path.join(NEW_PROJECT_TEMPLATES_FOLDER, 'new723ScriptTemplate', 'script.py'),
+        );
         const showTextDocumentStub = sinon
             .stub(windowApis, 'showTextDocument')
             .resolves({} as TextEditor);
-        const pathExistsStub = sinon.stub(fsExtra, 'pathExists');
-        pathExistsStub.onFirstCall().resolves(true);
-        pathExistsStub.onSecondCall().resolves(false);
+        // Resolve existence by the requested path (the template exists, the new
+        // script does not) so the fixture does not depend on probe call order.
+        sinon.stub(fsExtra, 'pathExists').callsFake(async (checkedPath) => {
+            return path.resolve(String(checkedPath)) === templateFile;
+        });
         const copyStub = sinon.stub(fsExtra, 'copy').callsFake(async (_source, destination) => {
             await fs.copyFile(TEMPLATE_PATH, destination);
         });
@@ -558,4 +563,45 @@ suite('new723ScriptTemplate / NewScriptProject', () => {
         assert.strictEqual(instructionsStub.called, false);
         assert.strictEqual(promptStub.called, false);
     });
+
+    test('a substitution failure after copy removes the partially created script', async () => {
+        const rootUri = Uri.file(tmpDir);
+        const scriptDestination = path.resolve(rootUri.fsPath, 'substitution_failure.py');
+        const { copyStub, instructionsStub, replaceStub, showTextDocumentStub } = stubSuccessfulFileCreation();
+        const substitutionError = new Error('template substitution failed');
+        replaceStub.rejects(substitutionError);
+        const promptStub = sinon.stub(windowApis, 'showInputBoxWithButtons');
+        const addStub = sinon.stub().resolves();
+        const removeStub = sinon.stub();
+        const creator = new NewScriptProject({
+            add: addStub,
+            remove: removeStub,
+        } as unknown as PythonProjectManager);
+
+        await assert.rejects(
+            creator.create({
+                name: 'substitution_failure.py',
+                quickCreate: true,
+                rootUri,
+            }),
+            (error: unknown) => error === substitutionError,
+        );
+
+        assert.ok(copyStub.calledOnce, 'the template must be copied before substitution runs');
+        assert.ok(replaceStub.calledOnce);
+        await assert.rejects(
+            fs.readFile(scriptDestination),
+            (error: NodeJS.ErrnoException) => error.code === 'ENOENT',
+            'the copied script must be removed when substitution fails',
+        );
+        assert.strictEqual(addStub.called, false, 'registration must not run when substitution fails');
+        assert.strictEqual(
+            removeStub.called,
+            false,
+            'project rollback must not run when registration was never attempted',
+        );
+        assert.strictEqual(instructionsStub.called, false);
+        assert.strictEqual(showTextDocumentStub.called, false);
+        assert.strictEqual(promptStub.called, false);
+    });
 });