qualia-framework 3.6.0 → 4.0.3

package/tests/runner.js

@@ -835,9 +835,11 @@ waves: 1
   it("init --force overwrites an existing project (preserves lifetime)", () => {
     const tmpDir = makeProject();
     try {
-      // Seed lifetime via close-milestone first
+      // Seed lifetime via close-milestone first. --force bypasses the v4
+      // readiness guards (MILESTONE_NOT_READY) since this test doesn't
+      // exercise the verification flow — it's focused on lifetime preservation.
       const c = spawnSync(process.execPath, [
-        path.join(BIN, "state.js"), "close-milestone",
+        path.join(BIN, "state.js"), "close-milestone", "--force",
       ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
       assert.equal(c.status, 0);
       const tBefore = JSON.parse(fs.readFileSync(path.join(tmpDir, ".planning", "tracking.json"), "utf8"));
@@ -863,8 +865,10 @@ waves: 1
   it("close-milestone refuses double-close (idempotency)", () => {
     const tmpDir = makeProject();
     try {
+      // First close uses --force to bypass v4 readiness guards — this test
+      // focuses on the ALREADY_CLOSED sentinel, not phase-verification gates.
       const r1 = spawnSync(process.execPath, [
-        path.join(BIN, "state.js"), "close-milestone",
+        path.join(BIN, "state.js"), "close-milestone", "--force",
       ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
       assert.equal(r1.status, 0);
       const out1 = JSON.parse(r1.stdout);
@@ -878,6 +882,8 @@ waves: 1
       t.milestone = out1.closed_milestone; // rewind
       fs.writeFileSync(tFile, JSON.stringify(t, null, 2) + "\n");
 
+      // Second close (without --force) must fail with ALREADY_CLOSED, which
+      // is checked BEFORE the readiness guards in cmdCloseMilestone.
       const r2 = spawnSync(process.execPath, [
         path.join(BIN, "state.js"), "close-milestone",
       ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
@@ -893,7 +899,7 @@ waves: 1
     const tmpDir = makeProject();
     try {
       const r1 = spawnSync(process.execPath, [
-        path.join(BIN, "state.js"), "close-milestone",
+        path.join(BIN, "state.js"), "close-milestone", "--force",
       ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
       assert.equal(r1.status, 0);
 
@@ -1002,6 +1008,165 @@ waves: 1
     }
   });
 
+  // ─── v4.0.0: milestone readiness guards + milestones[] summary ─
+  it("close-milestone refuses unverified phases (MILESTONE_NOT_READY)", () => {
+    const tmpDir = makeProject();
+    try {
+      // No phases verified yet — close-milestone (without --force) must refuse.
+      const r = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "close-milestone",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 1);
+      const out = JSON.parse(r.stdout);
+      assert.equal(out.error, "MILESTONE_NOT_READY");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("close-milestone refuses single-phase milestones (MILESTONE_TOO_SMALL)", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-single-"));
+    try {
+      const init = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "init",
+        "--project", "SingleProject",
+        "--phases", '[{"name":"Only","goal":"Y"}]',
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(init.status, 0);
+
+      // Single-phase milestone — even if the phase were verified, the size
+      // guard catches it first. A milestone needs ≥ 2 phases without --force.
+      const r = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "close-milestone",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 1);
+      const out = JSON.parse(r.stdout);
+      assert.equal(out.error, "MILESTONE_TOO_SMALL");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("close-milestone appends a summary to milestones[]", () => {
+    const tmpDir = makeProject();
+    try {
+      const r = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "close-milestone", "--force",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 0);
+
+      const tFile = path.join(tmpDir, ".planning", "tracking.json");
+      const t = JSON.parse(fs.readFileSync(tFile, "utf8"));
+      assert.ok(Array.isArray(t.milestones), "milestones[] must exist");
+      assert.equal(t.milestones.length, 1);
+      const m1 = t.milestones[0];
+      assert.equal(m1.num, 1);
+      assert.ok(m1.total_phases >= 2, "total_phases should reflect seeded phases");
+      assert.ok(typeof m1.closed_at === "string" && m1.closed_at.length > 0);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("milestone summary captures cumulative tasks_completed, not current phase only", () => {
+    const tmpDir = makeProject();
+    try {
+      // Simulate 2 phases each with 3 tasks verified pass. This bumps
+      // lifetime.tasks_completed to 6. The milestone close summary should
+      // reflect 6, not just 3 (the last phase's tasks_done).
+      for (const phase of [1, 2]) {
+        const planFile = path.join(tmpDir, ".planning", `phase-${phase}-plan.md`);
+        fs.writeFileSync(planFile, `---
+phase: ${phase}
+goal: "x"
+tasks: 1
+waves: 1
+---
+
+## Task 1 — x
+**Wave:** 1
+**Files:** x.ts
+**Depends on:** none
+**Acceptance Criteria:**
+- ok
+`);
+        const verFile = path.join(tmpDir, ".planning", `phase-${phase}-verification.md`);
+        // Plan → built → verified
+        let r = spawnSync(process.execPath, [path.join(BIN, "state.js"), "transition", "--to", "planned", "--phase", String(phase)],
+          { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+        assert.equal(r.status, 0, `planned transition failed for phase ${phase}: ${r.stderr || r.stdout}`);
+        r = spawnSync(process.execPath, [path.join(BIN, "state.js"), "transition", "--to", "built", "--phase", String(phase), "--tasks-done", "3", "--tasks-total", "3"],
+          { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+        assert.equal(r.status, 0, `built transition failed for phase ${phase}: ${r.stderr || r.stdout}`);
+        fs.writeFileSync(verFile, "result: PASS");
+        r = spawnSync(process.execPath, [path.join(BIN, "state.js"), "transition", "--to", "verified", "--phase", String(phase), "--verification", "pass"],
+          { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+        assert.equal(r.status, 0, `verified transition failed for phase ${phase}: ${r.stderr || r.stdout}`);
+      }
+
+      // Close milestone
+      const r = spawnSync(process.execPath, [path.join(BIN, "state.js"), "close-milestone"],
+        { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 0, `close-milestone failed: ${r.stderr || r.stdout}`);
+
+      const t = JSON.parse(fs.readFileSync(path.join(tmpDir, ".planning", "tracking.json"), "utf8"));
+      assert.equal(t.lifetime.tasks_completed, 6, "lifetime should have 6 tasks (2 phases × 3 tasks)");
+      assert.equal(t.milestones.length, 1);
+      assert.equal(t.milestones[0].tasks_completed, 6, "milestone summary should cumulate all 6 tasks, not just the last phase's 3");
+      assert.equal(t.milestones[0].phases_completed, 2);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("build_count bumps on each 'built' transition", () => {
+    const tmpDir = makeProject();
+    try {
+      const tFile = path.join(tmpDir, ".planning", "tracking.json");
+      const before = JSON.parse(fs.readFileSync(tFile, "utf8")).build_count || 0;
+
+      fs.writeFileSync(path.join(tmpDir, ".planning", "phase-1-plan.md"), `---
+phase: 1
+goal: "x"
+tasks: 1
+waves: 1
+---
+
+## Task 1 — x
+**Wave:** 1
+**Files:** x.ts
+**Depends on:** none
+**Acceptance Criteria:**
+- ok
+`);
+      spawnSync(process.execPath, [path.join(BIN, "state.js"), "transition", "--to", "planned", "--phase", "1"],
+        { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      const r = spawnSync(process.execPath, [path.join(BIN, "state.js"), "transition", "--to", "built", "--phase", "1", "--tasks-done", "1", "--tasks-total", "1"],
+        { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 0);
+
+      const after = JSON.parse(fs.readFileSync(tFile, "utf8")).build_count || 0;
+      assert.equal(after, before + 1, "build_count should bump on 'built' transition");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("check exposes milestones[] and milestone_name in output", () => {
+    const tmpDir = makeProject();
+    try {
+      const r = spawnSync(process.execPath, [
+        path.join(BIN, "state.js"), "check",
+      ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      assert.equal(r.status, 0);
+      const out = JSON.parse(r.stdout);
+      assert.ok(Array.isArray(out.milestones), "check must expose milestones[]");
+      assert.ok(typeof out.milestone_name === "string", "check must expose milestone_name");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
   // ─── v3.5.0: CRLF tolerance in parseStateMd ────────────
   it("parseStateMd tolerates CRLF line endings (Windows-edited STATE.md)", () => {
     const tmpDir = makeProject();
@@ -1033,6 +1198,96 @@ waves: 1
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
   });
+
+  // ─── v4 regression: deploy_count actually increments on shipped ───
+  it("transition --to shipped increments deploy_count", () => {
+    const tmpDir = makeProject();
+    try {
+      // Walk both phases through verified, then polished, then shipped.
+      makeValidPlan(tmpDir, 1);
+      runState(["transition", "--to", "planned"], tmpDir);
+      runState(["transition", "--to", "built", "--tasks-done", "1", "--tasks-total", "1"], tmpDir);
+      fs.writeFileSync(path.join(tmpDir, ".planning", "phase-1-verification.md"), "# pass\n");
+      runState(["transition", "--to", "verified", "--verification", "pass"], tmpDir);
+
+      makeValidPlan(tmpDir, 2);
+      runState(["transition", "--to", "planned"], tmpDir);
+      runState(["transition", "--to", "built", "--tasks-done", "1", "--tasks-total", "1"], tmpDir);
+      fs.writeFileSync(path.join(tmpDir, ".planning", "phase-2-verification.md"), "# pass\n");
+      runState(["transition", "--to", "verified", "--verification", "pass"], tmpDir);
+      runState(["transition", "--to", "polished"], tmpDir);
+
+      const before = JSON.parse(fs.readFileSync(path.join(tmpDir, ".planning", "tracking.json"), "utf8"));
+      assert.equal(parseInt(before.deploy_count) || 0, 0, "deploy_count starts at 0");
+
+      const r = runState(["transition", "--to", "shipped", "--deployed-url", "https://x.test"], tmpDir);
+      assert.equal(r.status, 0, `shipped transition failed: ${r.stdout} ${r.stderr}`);
+      const after = JSON.parse(fs.readFileSync(path.join(tmpDir, ".planning", "tracking.json"), "utf8"));
+      assert.equal(parseInt(after.deploy_count), 1, "deploy_count must increment to 1");
+      assert.equal(after.deployed_url, "https://x.test");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // ─── v4.0.2: write-ahead journal recovery ─────────────────
+  // Simulate a crashed previous mutator by dropping a .state.journal file
+  // with pre-transition snapshots of STATE.md and tracking.json. The next
+  // mutator invocation must restore both files from the journal and remove it.
+  it("recovers STATE.md + tracking.json from .state.journal on next mutator", () => {
+    const tmpDir = makeProject();
+    try {
+      const statePath = path.join(tmpDir, ".planning", "STATE.md");
+      const trackPath = path.join(tmpDir, ".planning", "tracking.json");
+      const journalPath = path.join(tmpDir, ".planning", ".state.journal");
+
+      const origState = fs.readFileSync(statePath, "utf8");
+      const origTracking = fs.readFileSync(trackPath, "utf8");
+
+      // Corrupt STATE.md and tracking.json to simulate a half-completed write.
+      fs.writeFileSync(statePath, "# CORRUPTED\n");
+      fs.writeFileSync(trackPath, '{"corrupt":true}\n');
+
+      // Drop a journal that would have been written before the corruption.
+      fs.writeFileSync(journalPath, JSON.stringify({
+        ts: new Date().toISOString(),
+        pid: 99999,
+        state: origState,
+        tracking: origTracking,
+      }));
+
+      // Any mutator should trigger recovery. Use `fix` (a cheap mutator).
+      const r = runState(["fix"], tmpDir);
+      // Not asserting r.status — fix may succeed or report nothing to fix.
+      // What matters: STATE.md and tracking.json were restored and journal is gone.
+      assert.equal(fs.existsSync(journalPath), false, "journal must be removed after recovery");
+      const recoveredState = fs.readFileSync(statePath, "utf8");
+      const recoveredTracking = fs.readFileSync(trackPath, "utf8");
+      assert.ok(recoveredState.includes("Current Position") || recoveredState === origState,
+        "STATE.md must be restored from journal");
+      assert.notStrictEqual(recoveredTracking, '{"corrupt":true}\n',
+        "tracking.json must no longer be the corrupted snapshot");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // ─── v4.0.2: corrupt journal is tolerated, not fatal ──────
+  it("corrupt .state.journal is cleared without crashing mutator", () => {
+    const tmpDir = makeProject();
+    try {
+      const journalPath = path.join(tmpDir, ".planning", ".state.journal");
+      fs.writeFileSync(journalPath, "{not valid json");
+      const r = runState(["check"], tmpDir);
+      // check is read-only so it won't recover; use a mutator.
+      runState(["fix"], tmpDir);
+      assert.equal(fs.existsSync(journalPath), false,
+        "corrupt journal must be cleaned up so we don't loop on recovery");
+      assert.equal(r.status, 0, "check should still work with a stray journal file");
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
 });
 
 // ═══════════════════════════════════════════════════════════
@@ -1290,7 +1545,7 @@ describe("Hooks", () => {
       const r = spawnSync(process.execPath, [path.join(HOOKS, "pre-deploy-gate.js")], {
         encoding: "utf8", cwd: tmpDir, timeout: 10000, stdio: ["pipe", "pipe", "pipe"],
       });
-      assert.equal(r.status, 1);
+      assert.equal(r.status, 2, "PreToolUse hook must exit 2 to block");
       const combined = r.stdout + r.stderr;
       assert.match(combined, /BLOCKED/);
       assert.match(combined, /service_role/);
@@ -1307,7 +1562,7 @@ describe("Hooks", () => {
       const r = spawnSync(process.execPath, [path.join(HOOKS, "pre-deploy-gate.js")], {
         encoding: "utf8", cwd: tmpDir, timeout: 10000, stdio: ["pipe", "pipe", "pipe"],
       });
-      assert.equal(r.status, 1);
+      assert.equal(r.status, 2, "PreToolUse hook must exit 2 to block");
     } finally {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
@@ -1442,7 +1697,7 @@ describe("Hooks", () => {
       const r = spawnSync(process.execPath, [path.join(HOOKS, "pre-deploy-gate.js")], {
         encoding: "utf8", cwd: tmpDir, timeout: 10000, stdio: ["pipe", "pipe", "pipe"],
       });
-      assert.equal(r.status, 1);
+      assert.equal(r.status, 2, "PreToolUse hook must exit 2 to block");
     } finally {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
@@ -1678,6 +1933,28 @@ describe("Hooks", () => {
     assert.equal(r.status, 2, "UPDATE without WHERE must block");
   });
 
+  // v4.0.2: per-statement scan (previously a WHERE in ANY later statement
+  // made an unsafe DELETE pass).
+  it("migration-guard: DELETE FROM followed by unrelated SELECT WHERE -> blocked", () => {
+    const r = runHook("migration-guard.js", {
+      tool_input: {
+        file_path: "supabase/migrations/004b.sql",
+        content: "DELETE FROM users;\nSELECT * FROM logs WHERE ts > NOW();",
+      },
+    });
+    assert.equal(r.status, 2, "per-statement scan must still catch the DELETE without WHERE");
+  });
+
+  it("migration-guard: UPDATE SET without WHERE followed by unrelated WHERE -> blocked", () => {
+    const r = runHook("migration-guard.js", {
+      tool_input: {
+        file_path: "supabase/migrations/004c.sql",
+        content: "UPDATE accounts SET active = true;\nSELECT id FROM sessions WHERE expires > NOW();",
+      },
+    });
+    assert.equal(r.status, 2, "per-statement scan must catch the UPDATE without WHERE");
+  });
+
   it("migration-guard: GRANT TO PUBLIC -> blocked", () => {
     const r = runHook("migration-guard.js", {
       tool_input: { file_path: "supabase/migrations/005.sql", content: "GRANT ALL ON users TO PUBLIC;" },
@@ -2067,6 +2344,63 @@ describe("qualia-ui.js", () => {
       fs.rmSync(tmpHome, { recursive: true, force: true });
     }
   });
+
+  // ─── v4 regression: journey-tree renders without crashing ───
+  // Previously crashed with "Cannot access 'projectName' before initialization"
+  // because a const shadowed the fallback function inside its own initializer.
+  it("journey-tree renders milestones without crashing", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-jt-"));
+    try {
+      fs.mkdirSync(path.join(tmpDir, ".planning"), { recursive: true });
+      fs.writeFileSync(
+        path.join(tmpDir, ".planning", "JOURNEY.md"),
+        "# JOURNEY\n\n## Milestone 1 · Foundation\n\nWhy now.\n\n## Milestone 2 · Handoff\n\nDeliver.\n"
+      );
+      fs.writeFileSync(
+        path.join(tmpDir, ".planning", "tracking.json"),
+        JSON.stringify({ project: "jtproj", milestone: 1, milestones: [] })
+      );
+      fs.writeFileSync(
+        path.join(tmpDir, ".planning", "STATE.md"),
+        "---\nproject: jtproj\nphase: 1\nstatus: planning\nmilestone: 1\n---\n"
+      );
+      const r = runUI(["journey-tree"], { cwd: tmpDir, home: tmpDir });
+      assert.equal(r.status, 0, `journey-tree crashed: ${r.stderr}`);
+      const clean = stripAnsi(r.stdout);
+      assert.match(clean, /JOURNEY/);
+      assert.match(clean, /M1 · Foundation/);
+      assert.match(clean, /M2 · Handoff/);
+      assert.match(clean, /\[CURRENT\]/);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  // ─── v4 regression: journey-tree uses projectName() fallback when frontmatter missing ───
+  // Would previously throw ReferenceError because `const projectName` shadowed the
+  // function name inside its own initializer. Fallback resolves to basename(cwd).
+  it("journey-tree uses projectName() fallback when no project: in JOURNEY frontmatter", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-jt-fallback-"));
+    try {
+      fs.mkdirSync(path.join(tmpDir, ".planning"), { recursive: true });
+      fs.writeFileSync(
+        path.join(tmpDir, ".planning", "JOURNEY.md"),
+        "# JOURNEY\n\n## Milestone 1 · Foundation\n\nWhy now.\n\n## Milestone 2 · Handoff\n\nLast.\n"
+      );
+      fs.writeFileSync(
+        path.join(tmpDir, ".planning", "tracking.json"),
+        JSON.stringify({ project: "ignored-by-fallback", milestone: 1 })
+      );
+      const r = runUI(["journey-tree"], { cwd: tmpDir, home: tmpDir });
+      assert.equal(r.status, 0, `journey-tree crashed: ${r.stderr}`);
+      const clean = stripAnsi(r.stdout);
+      // Fallback is path.basename(cwd) — whatever the tmp dir is named.
+      assert.match(clean, new RegExp(path.basename(tmpDir)));
+      assert.match(clean, /M1 · Foundation/);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
 });
 
 // ═══════════════════════════════════════════════════════════
@@ -2275,6 +2609,46 @@ describe("install.js", () => {
     }
   });
 
+  // v4.0.2: reinstall merges hooks instead of clobbering.
+  it("re-install preserves user-added hooks in settings.json", () => {
+    const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-install-"));
+    try {
+      // Fresh install first, then inject a user-owned hook, then reinstall.
+      runInstall("QS-FAWZI-01", tmpHome);
+      const settingsPath = path.join(tmpHome, ".claude", "settings.json");
+      const before = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+
+      // Add a user hook to PreToolUse that is not a Qualia command.
+      const userHook = {
+        matcher: "Bash",
+        hooks: [
+          { type: "command", command: "echo user-owned-pre-tool-hook", timeout: 3 },
+        ],
+      };
+      before.hooks.PreToolUse = [userHook, ...(before.hooks.PreToolUse || [])];
+      fs.writeFileSync(settingsPath, JSON.stringify(before, null, 2));
+
+      const r = runInstall("QS-FAWZI-01", tmpHome);
+      assert.equal(r.status, 0);
+      const after = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+      const allCmds = [];
+      for (const block of after.hooks.PreToolUse || []) {
+        for (const h of (block.hooks || [])) allCmds.push(String(h.command || ""));
+      }
+      assert.ok(
+        allCmds.some((c) => c.includes("user-owned-pre-tool-hook")),
+        `user hook was clobbered by reinstall. Commands: ${allCmds.join(" | ")}`
+      );
+      // And Qualia hooks should still be there.
+      assert.ok(
+        allCmds.some((c) => c.includes("branch-guard.js")),
+        "Qualia hooks must still be present after reinstall"
+      );
+    } finally {
+      fs.rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+
   it("templates copied to qualia-templates/", () => {
     const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-install-"));
     try {