@swarmcraftai/cli 0.4.0 → 0.4.1

package/dist/main.cjs

@@ -403,13 +403,13 @@ var require_packetFile = __commonJS({
         ""
       ].join("\n");
     }
-    function renderProvisionalPacketFile(input2) {
-      const title = input2.title.trim();
-      const provisionalTaskId = input2.provisionalTaskId?.trim() || `${exports2.PROVISIONAL_TASK_ID_PREFIX}${slugify(title)}`;
+    function renderProvisionalPacketFile(input) {
+      const title = input.title.trim();
+      const provisionalTaskId = input.provisionalTaskId?.trim() || `${exports2.PROVISIONAL_TASK_ID_PREFIX}${slugify(title)}`;
       return [
         "---",
         "swarmcraftVersion: 2",
-        `projectId: ${input2.projectId}`,
+        `projectId: ${input.projectId}`,
         `taskId: ${provisionalTaskId}`,
         `title: ${escapeFrontmatterValue(title)}`,
         "lane: todo",
@@ -420,33 +420,33 @@ var require_packetFile = __commonJS({
         "",
         "## Goal",
         "",
-        input2.goal.trim() || "Describe the outcome in one short paragraph.",
+        input.goal.trim() || "Describe the outcome in one short paragraph.",
         "",
         "## Doing Checklist",
         "",
         CHECKLIST_SYNC_COMMENT,
         "",
-        renderProvisionalChecklist(input2.checklists.doing),
+        renderProvisionalChecklist(input.checklists.doing),
         "",
         "## Checking Checklist",
         "",
         CHECKLIST_SYNC_COMMENT,
         "",
-        renderProvisionalChecklist(input2.checklists.checking),
+        renderProvisionalChecklist(input.checklists.checking),
         "",
         "## Reviewing Checklist",
         "",
         CHECKLIST_SYNC_COMMENT,
         "",
-        renderProvisionalChecklist(input2.checklists.reviewing),
+        renderProvisionalChecklist(input.checklists.reviewing),
         "",
         "## Notes",
         "",
-        input2.notes?.trim() ?? "",
+        input.notes?.trim() ?? "",
         "",
         "## Agent Update",
         "",
-        input2.agentUpdate?.trim() || "<!-- Short structured summary of what changed, what is blocked, and what still needs review. -->",
+        input.agentUpdate?.trim() || "<!-- Short structured summary of what changed, what is blocked, and what still needs review. -->",
         ""
       ].join("\n");
     }
@@ -544,14 +544,14 @@ ${rewrittenFrontmatter}
 ${body.startsWith("\n") ? body : `
 ${body}`}`;
     }
-    function rewritePacketFile(input2) {
-      let rewritten = rewritePacketFileMetadata3(input2.contents, {
-        lane: input2.lane,
-        syncRevision: parsePacketFile3(input2.contents).frontmatter.syncRevision,
-        lastSyncedAt: input2.syncedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    function rewritePacketFile(input) {
+      let rewritten = rewritePacketFileMetadata3(input.contents, {
+        lane: input.lane,
+        syncRevision: parsePacketFile3(input.contents).frontmatter.syncRevision,
+        lastSyncedAt: input.syncedAt ?? (/* @__PURE__ */ new Date()).toISOString()
       });
-      rewritten = markChecklistStageComplete(rewritten, input2.completeStage);
-      return appendAgentUpdateLines(rewritten, input2.agentUpdateLines);
+      rewritten = markChecklistStageComplete(rewritten, input.completeStage);
+      return appendAgentUpdateLines(rewritten, input.agentUpdateLines);
     }
     function markChecklistStageComplete(contents, checklistStage) {
       const heading = checklistSectionHeading(checklistStage);
@@ -1062,29 +1062,29 @@ var require_stageCommands = __commonJS({
         stageName: toStageName(stage.command)
       }
     ]));
-    function buildPacketStageCommand2(input2) {
-      const commandParts = COMMAND_BY_WORKFLOW_STATE[input2.workflowState];
+    function buildPacketStageCommand2(input) {
+      const commandParts = COMMAND_BY_WORKFLOW_STATE[input.workflowState];
       if (!commandParts) {
         return null;
       }
       return buildAssistantActionCommand({
         actionKey: commandParts.actionKey,
-        relativePacketFilePath: input2.relativePacketFilePath,
-        agentProvider: input2.agentProvider
+        relativePacketFilePath: input.relativePacketFilePath,
+        agentProvider: input.agentProvider
       });
     }
-    function buildAssistantActionCommand(input2) {
-      const action = (0, assistantActions_js_1.getSwarmCraftAssistantAction)(input2.actionKey);
-      const agentProvider = input2.agentProvider ?? exports2.DEFAULT_SWARMCRAFT_AGENT_PROVIDER;
+    function buildAssistantActionCommand(input) {
+      const action = (0, assistantActions_js_1.getSwarmCraftAssistantAction)(input.actionKey);
+      const agentProvider = input.agentProvider ?? exports2.DEFAULT_SWARMCRAFT_AGENT_PROVIDER;
       const invocation = agentProvider === "codex" ? action.codexInvocation : action.copilotInvocation;
-      const command = input2.relativePacketFilePath ? invocation.replace("<packet-path>", formatTaskArgument(input2.relativePacketFilePath)) : invocation;
+      const command = input.relativePacketFilePath ? invocation.replace("<packet-path>", formatTaskArgument(input.relativePacketFilePath)) : invocation;
       const args = [];
-      if (input2.relativePacketFilePath && command === invocation) {
-        const packetArgumentName = input2.actionKey === "test" ? "task" : "scope";
-        args.push(`${packetArgumentName}=${formatTaskArgument(input2.relativePacketFilePath)}`);
+      if (input.relativePacketFilePath && command === invocation) {
+        const packetArgumentName = input.actionKey === "test" ? "task" : "scope";
+        args.push(`${packetArgumentName}=${formatTaskArgument(input.relativePacketFilePath)}`);
       }
-      if (input2.scope?.trim()) {
-        args.push(`scope=${formatTaskArgument(input2.scope.trim())}`);
+      if (input.scope?.trim()) {
+        args.push(`scope=${formatTaskArgument(input.scope.trim())}`);
       }
       return [command, ...args].join(" ");
     }
@@ -2506,26 +2506,26 @@ var require_renderCopilotPrompts = __commonJS({
         ""
       ].join("\n");
     }
-    function renderLaneIndependentPromptFile(action, input2) {
+    function renderLaneIndependentPromptFile(action, input) {
       return [
         "---",
-        `description: '${input2.description}'`,
-        `argument-hint: '${input2.inputName}=<request-or-path>'`,
+        `description: '${input.description}'`,
+        `argument-hint: '${input.inputName}=<request-or-path>'`,
         "---",
         "",
         `#file:${action.copilotSkillPath}`,
         "",
-        `# ${input2.title}`,
+        `# ${input.title}`,
         "",
         "## Inputs",
         "",
-        `* \${input:${input2.inputName}}: ${input2.inputDescription}`,
+        `* \${input:${input.inputName}}: ${input.inputDescription}`,
         "",
         "## Requirements",
         "",
-        ...(0, packet_workflow_1.renderNumberedLines)(input2.requirements),
+        ...(0, packet_workflow_1.renderNumberedLines)(input.requirements),
         "",
-        `Proceed with the user's request using \`\${input:${input2.inputName}}\` as the action scope.`,
+        `Proceed with the user's request using \`\${input:${input.inputName}}\` as the action scope.`,
         ""
       ].join("\n");
     }
@@ -2850,6 +2850,8 @@ Prototype when seeing or operating the proposed experience would materially impr
 
 Do not force a prototype for routine backend work, dependency changes, migrations, or a decision already clear in text. Explain briefly when a prototype would add little value and continue the surrounding discovery or planning workflow.
 
+When a surrounding discovery or planning workflow invokes this skill again, inspect reviewed prototypes before choosing a path. Revise an existing prototype when the new questions share its actors, product shell, interaction model, and decision context. Create a separate focused prototype when a distinct role, operating context, workflow, or recovery model would make the existing artifact confusing. Preserve and cross-link related prototypes; do not collapse separate decision surfaces into one oversized demo.
+
 ## Build the smallest decision surface
 
 1. State the decision questions the prototype must answer before building it.
@@ -3983,19 +3985,19 @@ var require_trust = __commonJS({
       }
     };
     exports2.AccountingTrustError = AccountingTrustError;
-    function buildAccountingConsentDisclosure(input2) {
-      if (!Number.isInteger(input2.lookbackMonths) || input2.lookbackMonths < 1 || input2.lookbackMonths > 36 || input2.dataClasses.length === 0) {
+    function buildAccountingConsentDisclosure(input) {
+      if (!Number.isInteger(input.lookbackMonths) || input.lookbackMonths < 1 || input.lookbackMonths > 36 || input.dataClasses.length === 0) {
         throw new AccountingTrustError("INVALID_CONSENT", "Accounting consent requires a 1-36 month lookback and at least one named data class.");
       }
       return {
-        provider: input2.provider,
-        organizationLabel: input2.organizationLabel ?? null,
-        connectionMethod: input2.connectionMethod,
-        requestedScopes: input2.requestedScopes ?? [],
-        dataClasses: input2.dataClasses,
-        lookbackMonths: input2.lookbackMonths,
+        provider: input.provider,
+        organizationLabel: input.organizationLabel ?? null,
+        connectionMethod: input.connectionMethod,
+        requestedScopes: input.requestedScopes ?? [],
+        dataClasses: input.dataClasses,
+        lookbackMonths: input.lookbackMonths,
         outputPath: "docs/reports/spend-analysis.md",
-        providerPermissionCaveat: input2.providerPermissionCaveat ?? null,
+        providerPermissionCaveat: input.providerPermissionCaveat ?? null,
         localProcessing: "Provider responses and normalized transactions are processed in a bounded local run area outside the repository. Deterministic recurrence analysis runs locally.",
         swarmCraftProcessing: "SwarmCraft does not upload raw accounting transactions. A future OAuth broker may exchange authorization codes transiently only when a provider requires a confidential client; that path is disabled until separately approved.",
         aiProcessing: "The configured AI assistant may receive minimized subscription candidates and evidence summaries for interpretation and report drafting. It must not receive access tokens, refresh tokens, raw provider payloads, account numbers, or unrelated transactions.",
@@ -4077,12 +4079,12 @@ var require_analysis = __commonJS({
       }
       return normalized;
     }
-    function analyseRecurringSpend(input2) {
-      const aliasRules = input2.aliases ?? [];
-      const known = new Map((input2.knownSoftware ?? []).map((vendor) => [normalizeMerchantIdentity(vendor.canonicalMerchant, aliasRules), vendor.displayName]));
+    function analyseRecurringSpend(input) {
+      const aliasRules = input.aliases ?? [];
+      const known = new Map((input.knownSoftware ?? []).map((vendor) => [normalizeMerchantIdentity(vendor.canonicalMerchant, aliasRules), vendor.displayName]));
       const currenciesByMerchant = /* @__PURE__ */ new Map();
       const groups = /* @__PURE__ */ new Map();
-      for (const transaction of input2.transactions) {
+      for (const transaction of input.transactions) {
         validateTransaction(transaction);
         const merchant = normalizeMerchantIdentity(transaction.merchantIdentity, aliasRules);
         const currency = transaction.currency.toUpperCase();
@@ -4155,11 +4157,11 @@ var require_analysis = __commonJS({
           limitations
         });
       }
-      const corrected = applyCorrections(findings, input2.corrections ?? []);
+      const corrected = applyCorrections(findings, input.corrections ?? []);
       return {
         findings: corrected.sort((left, right) => left.id.localeCompare(right.id)),
         ignoredOneOffGroups,
-        currencies: [...new Set(input2.transactions.map((transaction) => transaction.currency.toUpperCase()))].sort(),
+        currencies: [...new Set(input.transactions.map((transaction) => transaction.currency.toUpperCase()))].sort(),
         limitations: [
           "Annualized values extrapolate observed cadence and are not forecasts or contract totals.",
           "Amounts in different currencies are never silently converted or combined.",
@@ -4167,16 +4169,16 @@ var require_analysis = __commonJS({
         ]
       };
     }
-    function renderSpendReport(input2) {
-      if (!input2.ownerReviewed)
+    function renderSpendReport(input) {
+      if (!input.ownerReviewed)
         throw new Error("Spend report must be owner-reviewed before rendering for the repository.");
-      return renderSpendReportProposal(input2);
+      return renderSpendReportProposal(input);
     }
-    function renderSpendReportProposal(input2) {
+    function renderSpendReportProposal(input) {
       const confidenceOrder = { high: 0, medium: 1, low: 2 };
-      const ranked = [...input2.result.findings].sort((left, right) => confidenceOrder[left.confidence] - confidenceOrder[right.confidence] || left.displayMerchant.localeCompare(right.displayMerchant));
+      const ranked = [...input.result.findings].sort((left, right) => confidenceOrder[left.confidence] - confidenceOrder[right.confidence] || left.displayMerchant.localeCompare(right.displayMerchant));
       const rows = ranked.map((finding) => `| \`${finding.id}\` | ${safeCell(finding.displayMerchant)} | ${finding.cadence} | ${finding.currency} ${formatMinor(finding.observedSpendMinor)} | ${finding.annualizedSpendMinor === null ? "Not estimated" : `${finding.currency} ${formatMinor(finding.annualizedSpendMinor)}`} | ${finding.classification} | ${finding.confidence} | ${finding.businessOwner ? safeCell(finding.businessOwner) : "Unconfirmed"} |`).join("\n") || "| \u2014 | No recurring candidates in scope | \u2014 | \u2014 | \u2014 | \u2014 | \u2014 | \u2014 |";
-      const previous = new Set(input2.previousFindingIds ?? []);
+      const previous = new Set(input.previousFindingIds ?? []);
       const current = new Set(ranked.map(({ id }) => id));
       const newIds = [...current].filter((id) => !previous.has(id));
       const continuingIds = [...current].filter((id) => previous.has(id));
@@ -4191,12 +4193,12 @@ var require_analysis = __commonJS({
 swarmcraftReport: 1
 reportType: spend-analysis
 ownerSkill: swarmcraft-spend-analysis
-generatedAt: ${input2.generatedAt}
-assessedRef: ${safeScalar(input2.assessedRef)}
-mode: ${input2.mode}
-scope: ${safeScalar(input2.scope)}
+generatedAt: ${input.generatedAt}
+assessedRef: ${safeScalar(input.assessedRef)}
+mode: ${input.mode}
+scope: ${safeScalar(input.scope)}
 status: COMPLETE
-previousReportCommit: ${input2.previousReportCommit ?? "null"}
+previousReportCommit: ${input.previousReportCommit ?? "null"}
 ---
 
 # Spend Analysis
@@ -4245,14 +4247,14 @@ ${ranked.filter((finding) => finding.businessOwner || finding.uncertaintyNote ||
 
 ## Limitations
 
-${[.../* @__PURE__ */ new Set([...input2.result.limitations, ...input2.result.findings.flatMap((finding) => finding.limitations)])].map((limitation) => `- ${safeText(limitation)}`).join("\n")}
+${[.../* @__PURE__ */ new Set([...input.result.limitations, ...input.result.findings.flatMap((finding) => finding.limitations)])].map((limitation) => `- ${safeText(limitation)}`).join("\n")}
 
 ## Run record
 
-- Assessed revision: \`${safeText(input2.assessedRef)}\`
-- Findings: ${input2.result.findings.length}
-- Ignored one-off groups: ${input2.result.ignoredOneOffGroups}
-- Currencies reported separately: ${input2.result.currencies.join(", ") || "none"}
+- Assessed revision: \`${safeText(input.assessedRef)}\`
+- Findings: ${input.result.findings.length}
+- Ignored one-off groups: ${input.result.ignoredOneOffGroups}
+- Currencies reported separately: ${input.result.currencies.join(", ") || "none"}
 - Report commit message: \`SwarmCraft: Update Spend Analysis\`
 `;
     }
@@ -4351,8 +4353,8 @@ ${[.../* @__PURE__ */ new Set([...input2.result.limitations, ...input2.result.fi
       }
       return null;
     }
-    function buildConfidenceReasons(input2) {
-      return [input2.charges.length >= 6 ? "six-or-more-charges" : "multiple-charges", input2.cadence !== "irregular" ? "repeatable-cadence" : "irregular-cadence", input2.amountVariation <= 0.1 ? "stable-amount" : "variable-amount", input2.classification === "known-saas" ? "known-software-vendor" : input2.classification === "likely-software" ? "software-category" : input2.classification === "ambiguous-processor" ? "processor-ambiguity" : "unknown-merchant", input2.reconciled === input2.charges.length ? "reconciled-evidence" : "mixed-reconciliation"].filter(Boolean);
+    function buildConfidenceReasons(input) {
+      return [input.charges.length >= 6 ? "six-or-more-charges" : "multiple-charges", input.cadence !== "irregular" ? "repeatable-cadence" : "irregular-cadence", input.amountVariation <= 0.1 ? "stable-amount" : "variable-amount", input.classification === "known-saas" ? "known-software-vendor" : input.classification === "likely-software" ? "software-category" : input.classification === "ambiguous-processor" ? "processor-ambiguity" : "unknown-merchant", input.reconciled === input.charges.length ? "reconciled-evidence" : "mixed-reconciliation"].filter(Boolean);
     }
     function confidenceWeight(reason) {
       return { "six-or-more-charges": 30, "multiple-charges": 15, "repeatable-cadence": 25, "irregular-cadence": 5, "stable-amount": 15, "variable-amount": 5, "known-software-vendor": 25, "software-category": 15, "processor-ambiguity": 0, "unknown-merchant": 5, "reconciled-evidence": 10, "mixed-reconciliation": 3 }[reason] ?? 0;
@@ -8777,7 +8779,7 @@ var require_stream_writable = __commonJS({
   "../../node_modules/.pnpm/readable-stream@2.3.8/node_modules/readable-stream/lib/_stream_writable.js"(exports2, module2) {
     "use strict";
     var pna = require_process_nextick_args();
-    module2.exports = Writable;
+    module2.exports = Writable2;
     function CorkedRequest(state) {
       var _this = this;
       this.next = null;
@@ -8788,7 +8790,7 @@ var require_stream_writable = __commonJS({
     }
     var asyncWrite = !process.browser && ["v0.10", "v0.9."].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
     var Duplex;
-    Writable.WritableState = WritableState;
+    Writable2.WritableState = WritableState;
     var util = Object.create(require_util());
     util.inherits = require_inherits();
     var internalUtil = {
@@ -8805,7 +8807,7 @@ var require_stream_writable = __commonJS({
       return Buffer2.isBuffer(obj2) || obj2 instanceof OurUint8Array;
     }
     var destroyImpl = require_destroy();
-    util.inherits(Writable, Stream);
+    util.inherits(Writable2, Stream);
     function nop() {
     }
     function WritableState(options, stream) {
@@ -8870,10 +8872,10 @@ var require_stream_writable = __commonJS({
     var realHasInstance;
     if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
       realHasInstance = Function.prototype[Symbol.hasInstance];
-      Object.defineProperty(Writable, Symbol.hasInstance, {
+      Object.defineProperty(Writable2, Symbol.hasInstance, {
         value: function(object) {
           if (realHasInstance.call(this, object)) return true;
-          if (this !== Writable) return false;
+          if (this !== Writable2) return false;
           return object && object._writableState instanceof WritableState;
         }
       });
@@ -8882,10 +8884,10 @@ var require_stream_writable = __commonJS({
         return object instanceof this;
       };
     }
-    function Writable(options) {
+    function Writable2(options) {
       Duplex = Duplex || require_stream_duplex();
-      if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
-        return new Writable(options);
+      if (!realHasInstance.call(Writable2, this) && !(this instanceof Duplex)) {
+        return new Writable2(options);
       }
       this._writableState = new WritableState(options, this);
       this.writable = true;
@@ -8897,7 +8899,7 @@ var require_stream_writable = __commonJS({
       }
       Stream.call(this);
     }
-    Writable.prototype.pipe = function() {
+    Writable2.prototype.pipe = function() {
       this.emit("error", new Error("Cannot pipe, not readable"));
     };
     function writeAfterEnd(stream, cb) {
@@ -8920,7 +8922,7 @@ var require_stream_writable = __commonJS({
       }
       return valid;
     }
-    Writable.prototype.write = function(chunk, encoding, cb) {
+    Writable2.prototype.write = function(chunk, encoding, cb) {
       var state = this._writableState;
       var ret2 = false;
       var isBuf = !state.objectMode && _isUint8Array(chunk);
@@ -8941,18 +8943,18 @@ var require_stream_writable = __commonJS({
       }
       return ret2;
     };
-    Writable.prototype.cork = function() {
+    Writable2.prototype.cork = function() {
       var state = this._writableState;
       state.corked++;
     };
-    Writable.prototype.uncork = function() {
+    Writable2.prototype.uncork = function() {
       var state = this._writableState;
       if (state.corked) {
         state.corked--;
         if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
       }
     };
-    Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+    Writable2.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
       if (typeof encoding === "string") encoding = encoding.toLowerCase();
       if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1)) throw new TypeError("Unknown encoding: " + encoding);
       this._writableState.defaultEncoding = encoding;
@@ -8964,7 +8966,7 @@ var require_stream_writable = __commonJS({
       }
       return chunk;
     }
-    Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
+    Object.defineProperty(Writable2.prototype, "writableHighWaterMark", {
       // making it explicit this property is not enumerable
       // because otherwise some prototype manipulation in
       // userland will fail
@@ -9110,11 +9112,11 @@ var require_stream_writable = __commonJS({
       state.bufferedRequest = entry;
       state.bufferProcessing = false;
     }
-    Writable.prototype._write = function(chunk, encoding, cb) {
+    Writable2.prototype._write = function(chunk, encoding, cb) {
       cb(new Error("_write() is not implemented"));
     };
-    Writable.prototype._writev = null;
-    Writable.prototype.end = function(chunk, encoding, cb) {
+    Writable2.prototype._writev = null;
+    Writable2.prototype.end = function(chunk, encoding, cb) {
       var state = this._writableState;
       if (typeof chunk === "function") {
         cb = chunk;
@@ -9189,7 +9191,7 @@ var require_stream_writable = __commonJS({
       }
       state.corkedRequestsFree.next = corkReq;
     }
-    Object.defineProperty(Writable.prototype, "destroyed", {
+    Object.defineProperty(Writable2.prototype, "destroyed", {
       get: function() {
         if (this._writableState === void 0) {
           return false;
@@ -9203,9 +9205,9 @@ var require_stream_writable = __commonJS({
         this._writableState.destroyed = value;
       }
     });
-    Writable.prototype.destroy = destroyImpl.destroy;
-    Writable.prototype._undestroy = destroyImpl.undestroy;
-    Writable.prototype._destroy = function(err, cb) {
+    Writable2.prototype.destroy = destroyImpl.destroy;
+    Writable2.prototype._undestroy = destroyImpl.undestroy;
+    Writable2.prototype._destroy = function(err, cb) {
       this.end();
       cb(err);
     };
@@ -9228,13 +9230,13 @@ var require_stream_duplex = __commonJS({
     var util = Object.create(require_util());
     util.inherits = require_inherits();
     var Readable = require_stream_readable();
-    var Writable = require_stream_writable();
+    var Writable2 = require_stream_writable();
     util.inherits(Duplex, Readable);
     {
-      keys = objectKeys(Writable.prototype);
+      keys = objectKeys(Writable2.prototype);
       for (v = 0; v < keys.length; v++) {
         method = keys[v];
-        if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+        if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable2.prototype[method];
       }
     }
     var keys;
@@ -9243,7 +9245,7 @@ var require_stream_duplex = __commonJS({
     function Duplex(options) {
       if (!(this instanceof Duplex)) return new Duplex(options);
       Readable.call(this, options);
-      Writable.call(this, options);
+      Writable2.call(this, options);
       if (options && options.readable === false) this.readable = false;
       if (options && options.writable === false) this.writable = false;
       this.allowHalfOpen = true;
@@ -10404,72 +10406,72 @@ var require_base64 = __commonJS({
     var utils = require_utils();
     var support = require_support();
     var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
-    exports2.encode = function(input2) {
-      var output2 = [];
+    exports2.encode = function(input) {
+      var output = [];
       var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
-      var i = 0, len = input2.length, remainingBytes = len;
-      var isArray = utils.getTypeOf(input2) !== "string";
-      while (i < input2.length) {
+      var i = 0, len = input.length, remainingBytes = len;
+      var isArray = utils.getTypeOf(input) !== "string";
+      while (i < input.length) {
         remainingBytes = len - i;
         if (!isArray) {
-          chr1 = input2.charCodeAt(i++);
-          chr2 = i < len ? input2.charCodeAt(i++) : 0;
-          chr3 = i < len ? input2.charCodeAt(i++) : 0;
+          chr1 = input.charCodeAt(i++);
+          chr2 = i < len ? input.charCodeAt(i++) : 0;
+          chr3 = i < len ? input.charCodeAt(i++) : 0;
         } else {
-          chr1 = input2[i++];
-          chr2 = i < len ? input2[i++] : 0;
-          chr3 = i < len ? input2[i++] : 0;
+          chr1 = input[i++];
+          chr2 = i < len ? input[i++] : 0;
+          chr3 = i < len ? input[i++] : 0;
         }
         enc1 = chr1 >> 2;
         enc2 = (chr1 & 3) << 4 | chr2 >> 4;
         enc3 = remainingBytes > 1 ? (chr2 & 15) << 2 | chr3 >> 6 : 64;
         enc4 = remainingBytes > 2 ? chr3 & 63 : 64;
-        output2.push(_keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4));
+        output.push(_keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4));
       }
-      return output2.join("");
+      return output.join("");
     };
-    exports2.decode = function(input2) {
+    exports2.decode = function(input) {
       var chr1, chr2, chr3;
       var enc1, enc2, enc3, enc4;
       var i = 0, resultIndex = 0;
       var dataUrlPrefix = "data:";
-      if (input2.substr(0, dataUrlPrefix.length) === dataUrlPrefix) {
+      if (input.substr(0, dataUrlPrefix.length) === dataUrlPrefix) {
         throw new Error("Invalid base64 input, it looks like a data url.");
       }
-      input2 = input2.replace(/[^A-Za-z0-9+/=]/g, "");
-      var totalLength = input2.length * 3 / 4;
-      if (input2.charAt(input2.length - 1) === _keyStr.charAt(64)) {
+      input = input.replace(/[^A-Za-z0-9+/=]/g, "");
+      var totalLength = input.length * 3 / 4;
+      if (input.charAt(input.length - 1) === _keyStr.charAt(64)) {
         totalLength--;
       }
-      if (input2.charAt(input2.length - 2) === _keyStr.charAt(64)) {
+      if (input.charAt(input.length - 2) === _keyStr.charAt(64)) {
         totalLength--;
       }
       if (totalLength % 1 !== 0) {
         throw new Error("Invalid base64 input, bad content length.");
       }
-      var output2;
+      var output;
       if (support.uint8array) {
-        output2 = new Uint8Array(totalLength | 0);
+        output = new Uint8Array(totalLength | 0);
       } else {
-        output2 = new Array(totalLength | 0);
+        output = new Array(totalLength | 0);
       }
-      while (i < input2.length) {
-        enc1 = _keyStr.indexOf(input2.charAt(i++));
-        enc2 = _keyStr.indexOf(input2.charAt(i++));
-        enc3 = _keyStr.indexOf(input2.charAt(i++));
-        enc4 = _keyStr.indexOf(input2.charAt(i++));
+      while (i < input.length) {
+        enc1 = _keyStr.indexOf(input.charAt(i++));
+        enc2 = _keyStr.indexOf(input.charAt(i++));
+        enc3 = _keyStr.indexOf(input.charAt(i++));
+        enc4 = _keyStr.indexOf(input.charAt(i++));
         chr1 = enc1 << 2 | enc2 >> 4;
         chr2 = (enc2 & 15) << 4 | enc3 >> 2;
         chr3 = (enc3 & 3) << 6 | enc4;
-        output2[resultIndex++] = chr1;
+        output[resultIndex++] = chr1;
         if (enc3 !== 64) {
-          output2[resultIndex++] = chr2;
+          output[resultIndex++] = chr2;
         }
         if (enc4 !== 64) {
-          output2[resultIndex++] = chr3;
+          output[resultIndex++] = chr3;
         }
       }
-      return output2;
+      return output;
     };
   }
 });
@@ -11073,8 +11075,8 @@ var require_utils = __commonJS({
         }
       }
     };
-    function identity(input2) {
-      return input2;
+    function identity(input) {
+      return input;
     }
     function stringToArrayLike(str, array) {
       for (var i = 0; i < str.length; ++i) {
@@ -11172,83 +11174,83 @@ var require_utils = __commonJS({
     var transform = {};
     transform["string"] = {
       "string": identity,
-      "array": function(input2) {
-        return stringToArrayLike(input2, new Array(input2.length));
+      "array": function(input) {
+        return stringToArrayLike(input, new Array(input.length));
       },
-      "arraybuffer": function(input2) {
-        return transform["string"]["uint8array"](input2).buffer;
+      "arraybuffer": function(input) {
+        return transform["string"]["uint8array"](input).buffer;
       },
-      "uint8array": function(input2) {
-        return stringToArrayLike(input2, new Uint8Array(input2.length));
+      "uint8array": function(input) {
+        return stringToArrayLike(input, new Uint8Array(input.length));
       },
-      "nodebuffer": function(input2) {
-        return stringToArrayLike(input2, nodejsUtils.allocBuffer(input2.length));
+      "nodebuffer": function(input) {
+        return stringToArrayLike(input, nodejsUtils.allocBuffer(input.length));
       }
     };
     transform["array"] = {
       "string": arrayLikeToString,
       "array": identity,
-      "arraybuffer": function(input2) {
-        return new Uint8Array(input2).buffer;
+      "arraybuffer": function(input) {
+        return new Uint8Array(input).buffer;
       },
-      "uint8array": function(input2) {
-        return new Uint8Array(input2);
+      "uint8array": function(input) {
+        return new Uint8Array(input);
       },
-      "nodebuffer": function(input2) {
-        return nodejsUtils.newBufferFrom(input2);
+      "nodebuffer": function(input) {
+        return nodejsUtils.newBufferFrom(input);
       }
     };
     transform["arraybuffer"] = {
-      "string": function(input2) {
-        return arrayLikeToString(new Uint8Array(input2));
+      "string": function(input) {
+        return arrayLikeToString(new Uint8Array(input));
       },
-      "array": function(input2) {
-        return arrayLikeToArrayLike(new Uint8Array(input2), new Array(input2.byteLength));
+      "array": function(input) {
+        return arrayLikeToArrayLike(new Uint8Array(input), new Array(input.byteLength));
       },
       "arraybuffer": identity,
-      "uint8array": function(input2) {
-        return new Uint8Array(input2);
+      "uint8array": function(input) {
+        return new Uint8Array(input);
       },
-      "nodebuffer": function(input2) {
-        return nodejsUtils.newBufferFrom(new Uint8Array(input2));
+      "nodebuffer": function(input) {
+        return nodejsUtils.newBufferFrom(new Uint8Array(input));
       }
     };
     transform["uint8array"] = {
       "string": arrayLikeToString,
-      "array": function(input2) {
-        return arrayLikeToArrayLike(input2, new Array(input2.length));
+      "array": function(input) {
+        return arrayLikeToArrayLike(input, new Array(input.length));
       },
-      "arraybuffer": function(input2) {
-        return input2.buffer;
+      "arraybuffer": function(input) {
+        return input.buffer;
       },
       "uint8array": identity,
-      "nodebuffer": function(input2) {
-        return nodejsUtils.newBufferFrom(input2);
+      "nodebuffer": function(input) {
+        return nodejsUtils.newBufferFrom(input);
       }
     };
     transform["nodebuffer"] = {
       "string": arrayLikeToString,
-      "array": function(input2) {
-        return arrayLikeToArrayLike(input2, new Array(input2.length));
+      "array": function(input) {
+        return arrayLikeToArrayLike(input, new Array(input.length));
       },
-      "arraybuffer": function(input2) {
-        return transform["nodebuffer"]["uint8array"](input2).buffer;
+      "arraybuffer": function(input) {
+        return transform["nodebuffer"]["uint8array"](input).buffer;
       },
-      "uint8array": function(input2) {
-        return arrayLikeToArrayLike(input2, new Uint8Array(input2.length));
+      "uint8array": function(input) {
+        return arrayLikeToArrayLike(input, new Uint8Array(input.length));
       },
       "nodebuffer": identity
     };
-    exports2.transformTo = function(outputType, input2) {
-      if (!input2) {
-        input2 = "";
+    exports2.transformTo = function(outputType, input) {
+      if (!input) {
+        input = "";
       }
       if (!outputType) {
-        return input2;
+        return input;
       }
       exports2.checkSupport(outputType);
-      var inputType = exports2.getTypeOf(input2);
-      var result = transform[inputType][outputType](input2);
+      var inputType = exports2.getTypeOf(input);
+      var result = transform[inputType][outputType](input);
       return result;
     };
     exports2.resolve = function(path10) {
@@ -11266,20 +11268,20 @@ var require_utils = __commonJS({
       }
       return result.join("/");
     };
-    exports2.getTypeOf = function(input2) {
-      if (typeof input2 === "string") {
+    exports2.getTypeOf = function(input) {
+      if (typeof input === "string") {
         return "string";
       }
-      if (Object.prototype.toString.call(input2) === "[object Array]") {
+      if (Object.prototype.toString.call(input) === "[object Array]") {
         return "array";
       }
-      if (support.nodebuffer && nodejsUtils.isBuffer(input2)) {
+      if (support.nodebuffer && nodejsUtils.isBuffer(input)) {
         return "nodebuffer";
       }
-      if (support.uint8array && input2 instanceof Uint8Array) {
+      if (support.uint8array && input instanceof Uint8Array) {
         return "uint8array";
       }
-      if (support.arraybuffer && input2 instanceof ArrayBuffer) {
+      if (support.arraybuffer && input instanceof ArrayBuffer) {
         return "arraybuffer";
       }
     };
@@ -12130,15 +12132,15 @@ var require_crc32 = __commonJS({
       }
       return crc ^ -1;
     }
-    module2.exports = function crc32wrapper(input2, crc) {
-      if (typeof input2 === "undefined" || !input2.length) {
+    module2.exports = function crc32wrapper(input, crc) {
+      if (typeof input === "undefined" || !input.length) {
         return 0;
       }
-      var isArray = utils.getTypeOf(input2) !== "string";
+      var isArray = utils.getTypeOf(input) !== "string";
       if (isArray) {
-        return crc32(crc | 0, input2, input2.length, 0);
+        return crc32(crc | 0, input, input.length, 0);
       } else {
-        return crc32str(crc | 0, input2, input2.length, 0);
+        return crc32str(crc | 0, input, input.length, 0);
       }
     };
   }
@@ -14138,7 +14140,7 @@ var require_deflate = __commonJS({
       var wrap;
       var avail;
       var next;
-      var input2;
+      var input;
       var tmpDict;
       if (!strm || !strm.state) {
         return Z_STREAM_ERROR;
@@ -14166,7 +14168,7 @@ var require_deflate = __commonJS({
       }
       avail = strm.avail_in;
       next = strm.next_in;
-      input2 = strm.input;
+      input = strm.input;
       strm.avail_in = dictLength;
       strm.next_in = 0;
       strm.input = dictionary;
@@ -14191,7 +14193,7 @@ var require_deflate = __commonJS({
       s.match_length = s.prev_length = MIN_MATCH - 1;
       s.match_available = 0;
       strm.next_in = next;
-      strm.input = input2;
+      strm.input = input;
       strm.avail_in = avail;
       s.wrap = wrap;
       return Z_OK;
@@ -14508,23 +14510,23 @@ var require_deflate2 = __commonJS({
       this.err = status;
       this.msg = this.strm.msg;
     };
-    function deflate(input2, options) {
+    function deflate(input, options) {
       var deflator = new Deflate(options);
-      deflator.push(input2, true);
+      deflator.push(input, true);
       if (deflator.err) {
         throw deflator.msg || msg[deflator.err];
       }
       return deflator.result;
     }
-    function deflateRaw(input2, options) {
+    function deflateRaw(input, options) {
       options = options || {};
       options.raw = true;
-      return deflate(input2, options);
+      return deflate(input, options);
     }
-    function gzip(input2, options) {
+    function gzip(input, options) {
       options = options || {};
       options.gzip = true;
-      return deflate(input2, options);
+      return deflate(input, options);
     }
     exports2.Deflate = Deflate;
     exports2.deflate = deflate;
@@ -14563,13 +14565,13 @@ var require_inffast = __commonJS({
       var dist;
       var from;
       var from_source;
-      var input2, output2;
+      var input, output;
       state = strm.state;
       _in = strm.next_in;
-      input2 = strm.input;
+      input = strm.input;
       last = _in + (strm.avail_in - 5);
       _out = strm.next_out;
-      output2 = strm.output;
+      output = strm.output;
       beg = _out - (start - strm.avail_out);
       end = _out + (strm.avail_out - 257);
       dmax = state.dmax;
@@ -14586,9 +14588,9 @@ var require_inffast = __commonJS({
       top:
         do {
           if (bits < 15) {
-            hold += input2[_in++] << bits;
+            hold += input[_in++] << bits;
             bits += 8;
-            hold += input2[_in++] << bits;
+            hold += input[_in++] << bits;
             bits += 8;
           }
           here = lcode[hold & lmask];
@@ -14599,13 +14601,13 @@ var require_inffast = __commonJS({
               bits -= op;
               op = here >>> 16 & 255;
               if (op === 0) {
-                output2[_out++] = here & 65535;
+                output[_out++] = here & 65535;
               } else if (op & 16) {
                 len = here & 65535;
                 op &= 15;
                 if (op) {
                   if (bits < op) {
-                    hold += input2[_in++] << bits;
+                    hold += input[_in++] << bits;
                     bits += 8;
                   }
                   len += hold & (1 << op) - 1;
@@ -14613,9 +14615,9 @@ var require_inffast = __commonJS({
                   bits -= op;
                 }
                 if (bits < 15) {
-                  hold += input2[_in++] << bits;
+                  hold += input[_in++] << bits;
                   bits += 8;
-                  hold += input2[_in++] << bits;
+                  hold += input[_in++] << bits;
                   bits += 8;
                 }
                 here = dcode[hold & dmask];
@@ -14629,10 +14631,10 @@ var require_inffast = __commonJS({
                       dist = here & 65535;
                       op &= 15;
                       if (bits < op) {
-                        hold += input2[_in++] << bits;
+                        hold += input[_in++] << bits;
                         bits += 8;
                         if (bits < op) {
-                          hold += input2[_in++] << bits;
+                          hold += input[_in++] << bits;
                           bits += 8;
                         }
                       }
@@ -14661,10 +14663,10 @@ var require_inffast = __commonJS({
                           if (op < len) {
                             len -= op;
                             do {
-                              output2[_out++] = s_window[from++];
+                              output[_out++] = s_window[from++];
                             } while (--op);
                             from = _out - dist;
-                            from_source = output2;
+                            from_source = output;
                           }
                         } else if (wnext < op) {
                           from += wsize + wnext - op;
@@ -14672,17 +14674,17 @@ var require_inffast = __commonJS({
                           if (op < len) {
                             len -= op;
                             do {
-                              output2[_out++] = s_window[from++];
+                              output[_out++] = s_window[from++];
                             } while (--op);
                             from = 0;
                             if (wnext < len) {
                               op = wnext;
                               len -= op;
                               do {
-                                output2[_out++] = s_window[from++];
+                                output[_out++] = s_window[from++];
                               } while (--op);
                               from = _out - dist;
-                              from_source = output2;
+                              from_source = output;
                             }
                           }
                         } else {
@@ -14690,36 +14692,36 @@ var require_inffast = __commonJS({
                           if (op < len) {
                             len -= op;
                             do {
-                              output2[_out++] = s_window[from++];
+                              output[_out++] = s_window[from++];
                             } while (--op);
                             from = _out - dist;
-                            from_source = output2;
+                            from_source = output;
                           }
                         }
                         while (len > 2) {
-                          output2[_out++] = from_source[from++];
-                          output2[_out++] = from_source[from++];
-                          output2[_out++] = from_source[from++];
+                          output[_out++] = from_source[from++];
+                          output[_out++] = from_source[from++];
+                          output[_out++] = from_source[from++];
                           len -= 3;
                         }
                         if (len) {
-                          output2[_out++] = from_source[from++];
+                          output[_out++] = from_source[from++];
                           if (len > 1) {
-                            output2[_out++] = from_source[from++];
+                            output[_out++] = from_source[from++];
                           }
                         }
                       } else {
                         from = _out - dist;
                         do {
-                          output2[_out++] = output2[from++];
-                          output2[_out++] = output2[from++];
-                          output2[_out++] = output2[from++];
+                          output[_out++] = output[from++];
+                          output[_out++] = output[from++];
+                          output[_out++] = output[from++];
                           len -= 3;
                         } while (len > 2);
                         if (len) {
-                          output2[_out++] = output2[from++];
+                          output[_out++] = output[from++];
                           if (len > 1) {
-                            output2[_out++] = output2[from++];
+                            output[_out++] = output[from++];
                           }
                         }
                       }
@@ -15328,7 +15330,7 @@ var require_inflate = __commonJS({
     }
     function inflate(strm, flush) {
       var state;
-      var input2, output2;
+      var input, output;
       var next;
       var put;
       var have, left;
@@ -15358,10 +15360,10 @@ var require_inflate = __commonJS({
         state.mode = TYPEDO;
       }
       put = strm.next_out;
-      output2 = strm.output;
+      output = strm.output;
       left = strm.avail_out;
       next = strm.next_in;
-      input2 = strm.input;
+      input = strm.input;
       have = strm.avail_in;
       hold = state.hold;
       bits = state.bits;
@@ -15381,7 +15383,7 @@ var require_inflate = __commonJS({
                   break inf_leave;
                 }
                 have--;
-                hold += input2[next++] << bits;
+                hold += input[next++] << bits;
                 bits += 8;
               }
               if (state.wrap & 2 && hold === 35615) {
@@ -15431,7 +15433,7 @@ var require_inflate = __commonJS({
                   break inf_leave;
                 }
                 have--;
-                hold += input2[next++] << bits;
+                hold += input[next++] << bits;
                 bits += 8;
               }
               state.flags = hold;
@@ -15463,7 +15465,7 @@ var require_inflate = __commonJS({
                   break inf_leave;
                 }
                 have--;
-                hold += input2[next++] << bits;
+                hold += input[next++] << bits;
                 bits += 8;
               }
               if (state.head) {
@@ -15486,7 +15488,7 @@ var require_inflate = __commonJS({
                   break inf_leave;
                 }
                 have--;
-                hold += input2[next++] << bits;
+                hold += input[next++] << bits;
                 bits += 8;
               }
               if (state.head) {
@@ -15509,7 +15511,7 @@ var require_inflate = __commonJS({
                     break inf_leave;
                   }
                   have--;
-                  hold += input2[next++] << bits;
+                  hold += input[next++] << bits;
                   bits += 8;
                 }
                 state.length = hold;
@@ -15542,7 +15544,7 @@ var require_inflate = __commonJS({
                     }
                     utils.arraySet(
                       state.head.extra,
-                      input2,
+                      input,
                       next,
                       // extra field is limited to 65536 bytes
                       // - no need for additional size check
@@ -15552,7 +15554,7 @@ var require_inflate = __commonJS({
                     );
                   }
                   if (state.flags & 512) {
-                    state.check = crc32(state.check, input2, copy, next);
+                    state.check = crc32(state.check, input, copy, next);
                   }
                   have -= copy;
                   next += copy;
@@ -15572,13 +15574,13 @@ var require_inflate = __commonJS({
                 }
                 copy = 0;
                 do {
-                  len = input2[next + copy++];
+                  len = input[next + copy++];
                   if (state.head && len && state.length < 65536) {
                     state.head.name += String.fromCharCode(len);
                   }
                 } while (len && copy < have);
                 if (state.flags & 512) {
-                  state.check = crc32(state.check, input2, copy, next);
+                  state.check = crc32(state.check, input, copy, next);
                 }
                 have -= copy;
                 next += copy;
@@ -15598,13 +15600,13 @@ var require_inflate = __commonJS({
                 }
                 copy = 0;
                 do {
-                  len = input2[next + copy++];
+                  len = input[next + copy++];
                   if (state.head && len && state.length < 65536) {
                     state.head.comment += String.fromCharCode(len);
                   }
                 } while (len && copy < have);
                 if (state.flags & 512) {
-                  state.check = crc32(state.check, input2, copy, next);
+                  state.check = crc32(state.check, input, copy, next);
                 }
                 have -= copy;
                 next += copy;
@@ -15623,7 +15625,7 @@ var require_inflate = __commonJS({
                     break inf_leave;
                   }
                   have--;
-                  hold += input2[next++] << bits;
+                  hold += input[next++] << bits;
                   bits += 8;
                 }
                 if (hold !== (state.check & 65535)) {
@@ -15647,7 +15649,7 @@ var require_inflate = __commonJS({
                   break inf_leave;
                 }
                 have--;
-                hold += input2[next++] << bits;
+                hold += input[next++] << bits;
                 bits += 8;
               }
               strm.adler = state.check = zswap32(hold);
@@ -15685,7 +15687,7 @@ var require_inflate = __commonJS({
                   break inf_leave;
                 }
                 have--;
-                hold += input2[next++] << bits;
+                hold += input[next++] << bits;
                 bits += 8;
               }
               state.last = hold & 1;
@@ -15722,7 +15724,7 @@ var require_inflate = __commonJS({
                   break inf_leave;
                 }
                 have--;
-                hold += input2[next++] << bits;
+                hold += input[next++] << bits;
                 bits += 8;
               }
               if ((hold & 65535) !== (hold >>> 16 ^ 65535)) {
@@ -15753,7 +15755,7 @@ var require_inflate = __commonJS({
                 if (copy === 0) {
                   break inf_leave;
                 }
-                utils.arraySet(output2, input2, next, copy, put);
+                utils.arraySet(output, input, next, copy, put);
                 have -= copy;
                 next += copy;
                 left -= copy;
@@ -15769,7 +15771,7 @@ var require_inflate = __commonJS({
                   break inf_leave;
                 }
                 have--;
-                hold += input2[next++] << bits;
+                hold += input[next++] << bits;
                 bits += 8;
               }
               state.nlen = (hold & 31) + 257;
@@ -15796,7 +15798,7 @@ var require_inflate = __commonJS({
                     break inf_leave;
                   }
                   have--;
-                  hold += input2[next++] << bits;
+                  hold += input[next++] << bits;
                   bits += 8;
                 }
                 state.lens[order[state.have++]] = hold & 7;
@@ -15833,7 +15835,7 @@ var require_inflate = __commonJS({
                     break inf_leave;
                   }
                   have--;
-                  hold += input2[next++] << bits;
+                  hold += input[next++] << bits;
                   bits += 8;
                 }
                 if (here_val < 16) {
@@ -15848,7 +15850,7 @@ var require_inflate = __commonJS({
                         break inf_leave;
                       }
                       have--;
-                      hold += input2[next++] << bits;
+                      hold += input[next++] << bits;
                       bits += 8;
                     }
                     hold >>>= here_bits;
@@ -15869,7 +15871,7 @@ var require_inflate = __commonJS({
                         break inf_leave;
                       }
                       have--;
-                      hold += input2[next++] << bits;
+                      hold += input[next++] << bits;
                       bits += 8;
                     }
                     hold >>>= here_bits;
@@ -15885,7 +15887,7 @@ var require_inflate = __commonJS({
                         break inf_leave;
                       }
                       have--;
-                      hold += input2[next++] << bits;
+                      hold += input[next++] << bits;
                       bits += 8;
                     }
                     hold >>>= here_bits;
@@ -15950,10 +15952,10 @@ var require_inflate = __commonJS({
                 state.bits = bits;
                 inflate_fast(strm, _out);
                 put = strm.next_out;
-                output2 = strm.output;
+                output = strm.output;
                 left = strm.avail_out;
                 next = strm.next_in;
-                input2 = strm.input;
+                input = strm.input;
                 have = strm.avail_in;
                 hold = state.hold;
                 bits = state.bits;
@@ -15975,7 +15977,7 @@ var require_inflate = __commonJS({
                   break inf_leave;
                 }
                 have--;
-                hold += input2[next++] << bits;
+                hold += input[next++] << bits;
                 bits += 8;
               }
               if (here_op && (here_op & 240) === 0) {
@@ -15994,7 +15996,7 @@ var require_inflate = __commonJS({
                     break inf_leave;
                   }
                   have--;
-                  hold += input2[next++] << bits;
+                  hold += input[next++] << bits;
                   bits += 8;
                 }
                 hold >>>= last_bits;
@@ -16030,7 +16032,7 @@ var require_inflate = __commonJS({
                     break inf_leave;
                   }
                   have--;
-                  hold += input2[next++] << bits;
+                  hold += input[next++] << bits;
                   bits += 8;
                 }
                 state.length += hold & (1 << state.extra) - 1;
@@ -16054,7 +16056,7 @@ var require_inflate = __commonJS({
                   break inf_leave;
                 }
                 have--;
-                hold += input2[next++] << bits;
+                hold += input[next++] << bits;
                 bits += 8;
               }
               if ((here_op & 240) === 0) {
@@ -16073,7 +16075,7 @@ var require_inflate = __commonJS({
                     break inf_leave;
                   }
                   have--;
-                  hold += input2[next++] << bits;
+                  hold += input[next++] << bits;
                   bits += 8;
                 }
                 hold >>>= last_bits;
@@ -16100,7 +16102,7 @@ var require_inflate = __commonJS({
                     break inf_leave;
                   }
                   have--;
-                  hold += input2[next++] << bits;
+                  hold += input[next++] << bits;
                   bits += 8;
                 }
                 state.offset += hold & (1 << state.extra) - 1;
@@ -16140,7 +16142,7 @@ var require_inflate = __commonJS({
                 }
                 from_source = state.window;
               } else {
-                from_source = output2;
+                from_source = output;
                 from = put - state.offset;
                 copy = state.length;
               }
@@ -16150,7 +16152,7 @@ var require_inflate = __commonJS({
               left -= copy;
               state.length -= copy;
               do {
-                output2[put++] = from_source[from++];
+                output[put++] = from_source[from++];
               } while (--copy);
               if (state.length === 0) {
                 state.mode = LEN;
@@ -16160,7 +16162,7 @@ var require_inflate = __commonJS({
               if (left === 0) {
                 break inf_leave;
               }
-              output2[put++] = state.length;
+              output[put++] = state.length;
               left--;
               state.mode = LEN;
               break;
@@ -16171,7 +16173,7 @@ var require_inflate = __commonJS({
                     break inf_leave;
                   }
                   have--;
-                  hold |= input2[next++] << bits;
+                  hold |= input[next++] << bits;
                   bits += 8;
                 }
                 _out -= left;
@@ -16179,7 +16181,7 @@ var require_inflate = __commonJS({
                 state.total += _out;
                 if (_out) {
                   strm.adler = state.check = /*UPDATE(state.check, put - _out, _out);*/
-                  state.flags ? crc32(state.check, output2, _out, put - _out) : adler32(state.check, output2, _out, put - _out);
+                  state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out);
                 }
                 _out = left;
                 if ((state.flags ? hold : zswap32(hold)) !== state.check) {
@@ -16199,7 +16201,7 @@ var require_inflate = __commonJS({
                     break inf_leave;
                   }
                   have--;
-                  hold += input2[next++] << bits;
+                  hold += input[next++] << bits;
                   bits += 8;
                 }
                 if (hold !== (state.total & 4294967295)) {
@@ -16245,7 +16247,7 @@ var require_inflate = __commonJS({
       state.total += _out;
       if (state.wrap && _out) {
         strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
-        state.flags ? crc32(state.check, output2, _out, strm.next_out - _out) : adler32(state.check, output2, _out, strm.next_out - _out);
+        state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out);
       }
       strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
       if ((_in === 0 && _out === 0 || flush === Z_FINISH) && ret2 === Z_OK) {
@@ -16538,18 +16540,18 @@ var require_inflate2 = __commonJS({
       this.err = status;
       this.msg = this.strm.msg;
     };
-    function inflate(input2, options) {
+    function inflate(input, options) {
       var inflator = new Inflate(options);
-      inflator.push(input2, true);
+      inflator.push(input, true);
       if (inflator.err) {
         throw inflator.msg || msg[inflator.err];
       }
       return inflator.result;
     }
-    function inflateRaw(input2, options) {
+    function inflateRaw(input, options) {
       options = options || {};
       options.raw = true;
-      return inflate(input2, options);
+      return inflate(input, options);
     }
     exports2.Inflate = Inflate;
     exports2.inflate = inflate;
@@ -18052,20 +18054,20 @@ var require_load = __commonJS({
         var zipEntries = results.shift();
         var files = zipEntries.files;
         for (var i = 0; i < files.length; i++) {
-          var input2 = files[i];
-          var unsafeName = input2.fileNameStr;
-          var safeName = utils.resolve(input2.fileNameStr);
-          zip.file(safeName, input2.decompressed, {
+          var input = files[i];
+          var unsafeName = input.fileNameStr;
+          var safeName = utils.resolve(input.fileNameStr);
+          zip.file(safeName, input.decompressed, {
             binary: true,
             optimizedBinaryString: true,
-            date: input2.date,
-            dir: input2.dir,
-            comment: input2.fileCommentStr.length ? input2.fileCommentStr : null,
-            unixPermissions: input2.unixPermissions,
-            dosPermissions: input2.dosPermissions,
+            date: input.date,
+            dir: input.dir,
+            comment: input.fileCommentStr.length ? input.fileCommentStr : null,
+            unixPermissions: input.unixPermissions,
+            dosPermissions: input.dosPermissions,
             createFolders: options.createFolders
           });
-          if (!input2.dir) {
+          if (!input.dir) {
             zip.file(safeName).unsafeOriginalName = unsafeName;
           }
         }
@@ -18180,15 +18182,15 @@ var require_buffer_list = __commonJS({
       var key = _toPrimitive(arg, "string");
       return typeof key === "symbol" ? key : String(key);
     }
-    function _toPrimitive(input2, hint) {
-      if (typeof input2 !== "object" || input2 === null) return input2;
-      var prim = input2[Symbol.toPrimitive];
+    function _toPrimitive(input, hint) {
+      if (typeof input !== "object" || input === null) return input;
+      var prim = input[Symbol.toPrimitive];
       if (prim !== void 0) {
-        var res = prim.call(input2, hint || "default");
+        var res = prim.call(input, hint || "default");
         if (typeof res !== "object") return res;
         throw new TypeError("@@toPrimitive must return a primitive value.");
       }
-      return (hint === "string" ? String : Number)(input2);
+      return (hint === "string" ? String : Number)(input);
     }
     var _require = require("buffer");
     var Buffer2 = _require.Buffer;
@@ -18582,7 +18584,7 @@ var require_state = __commonJS({
 var require_stream_writable2 = __commonJS({
   "../../node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/_stream_writable.js"(exports2, module2) {
     "use strict";
-    module2.exports = Writable;
+    module2.exports = Writable2;
     function CorkedRequest(state) {
       var _this = this;
       this.next = null;
@@ -18592,7 +18594,7 @@ var require_stream_writable2 = __commonJS({
       };
     }
     var Duplex;
-    Writable.WritableState = WritableState;
+    Writable2.WritableState = WritableState;
     var internalUtil = {
       deprecate: require_node()
     };
@@ -18619,7 +18621,7 @@ var require_stream_writable2 = __commonJS({
     var ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END;
     var ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
     var errorOrDestroy = destroyImpl.errorOrDestroy;
-    require_inherits()(Writable, Stream);
+    require_inherits()(Writable2, Stream);
     function nop() {
     }
     function WritableState(options, stream, isDuplex) {
@@ -18680,10 +18682,10 @@ var require_stream_writable2 = __commonJS({
     var realHasInstance;
     if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
       realHasInstance = Function.prototype[Symbol.hasInstance];
-      Object.defineProperty(Writable, Symbol.hasInstance, {
+      Object.defineProperty(Writable2, Symbol.hasInstance, {
         value: function value(object) {
           if (realHasInstance.call(this, object)) return true;
-          if (this !== Writable) return false;
+          if (this !== Writable2) return false;
           return object && object._writableState instanceof WritableState;
         }
       });
@@ -18692,10 +18694,10 @@ var require_stream_writable2 = __commonJS({
         return object instanceof this;
       };
     }
-    function Writable(options) {
+    function Writable2(options) {
       Duplex = Duplex || require_stream_duplex2();
       var isDuplex = this instanceof Duplex;
-      if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
+      if (!isDuplex && !realHasInstance.call(Writable2, this)) return new Writable2(options);
       this._writableState = new WritableState(options, this, isDuplex);
       this.writable = true;
       if (options) {
@@ -18706,7 +18708,7 @@ var require_stream_writable2 = __commonJS({
       }
       Stream.call(this);
     }
-    Writable.prototype.pipe = function() {
+    Writable2.prototype.pipe = function() {
       errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
     };
     function writeAfterEnd(stream, cb) {
@@ -18728,7 +18730,7 @@ var require_stream_writable2 = __commonJS({
       }
       return true;
     }
-    Writable.prototype.write = function(chunk, encoding, cb) {
+    Writable2.prototype.write = function(chunk, encoding, cb) {
       var state = this._writableState;
       var ret2 = false;
       var isBuf = !state.objectMode && _isUint8Array(chunk);
@@ -18749,23 +18751,23 @@ var require_stream_writable2 = __commonJS({
       }
       return ret2;
     };
-    Writable.prototype.cork = function() {
+    Writable2.prototype.cork = function() {
       this._writableState.corked++;
     };
-    Writable.prototype.uncork = function() {
+    Writable2.prototype.uncork = function() {
       var state = this._writableState;
       if (state.corked) {
         state.corked--;
         if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
       }
     };
-    Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+    Writable2.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
       if (typeof encoding === "string") encoding = encoding.toLowerCase();
       if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);
       this._writableState.defaultEncoding = encoding;
       return this;
     };
-    Object.defineProperty(Writable.prototype, "writableBuffer", {
+    Object.defineProperty(Writable2.prototype, "writableBuffer", {
       // making it explicit this property is not enumerable
       // because otherwise some prototype manipulation in
       // userland will fail
@@ -18780,7 +18782,7 @@ var require_stream_writable2 = __commonJS({
       }
       return chunk;
     }
-    Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
+    Object.defineProperty(Writable2.prototype, "writableHighWaterMark", {
       // making it explicit this property is not enumerable
       // because otherwise some prototype manipulation in
       // userland will fail
@@ -18928,11 +18930,11 @@ var require_stream_writable2 = __commonJS({
       state.bufferedRequest = entry;
       state.bufferProcessing = false;
     }
-    Writable.prototype._write = function(chunk, encoding, cb) {
+    Writable2.prototype._write = function(chunk, encoding, cb) {
       cb(new ERR_METHOD_NOT_IMPLEMENTED("_write()"));
     };
-    Writable.prototype._writev = null;
-    Writable.prototype.end = function(chunk, encoding, cb) {
+    Writable2.prototype._writev = null;
+    Writable2.prototype.end = function(chunk, encoding, cb) {
       var state = this._writableState;
       if (typeof chunk === "function") {
         cb = chunk;
@@ -18950,7 +18952,7 @@ var require_stream_writable2 = __commonJS({
       if (!state.ending) endWritable(this, state, cb);
       return this;
     };
-    Object.defineProperty(Writable.prototype, "writableLength", {
+    Object.defineProperty(Writable2.prototype, "writableLength", {
       // making it explicit this property is not enumerable
       // because otherwise some prototype manipulation in
       // userland will fail
@@ -19023,7 +19025,7 @@ var require_stream_writable2 = __commonJS({
       }
       state.corkedRequestsFree.next = corkReq;
     }
-    Object.defineProperty(Writable.prototype, "destroyed", {
+    Object.defineProperty(Writable2.prototype, "destroyed", {
       // making it explicit this property is not enumerable
       // because otherwise some prototype manipulation in
       // userland will fail
@@ -19041,9 +19043,9 @@ var require_stream_writable2 = __commonJS({
         this._writableState.destroyed = value;
       }
     });
-    Writable.prototype.destroy = destroyImpl.destroy;
-    Writable.prototype._undestroy = destroyImpl.undestroy;
-    Writable.prototype._destroy = function(err, cb) {
+    Writable2.prototype.destroy = destroyImpl.destroy;
+    Writable2.prototype._undestroy = destroyImpl.undestroy;
+    Writable2.prototype._destroy = function(err, cb) {
       cb(err);
     };
   }
@@ -19060,13 +19062,13 @@ var require_stream_duplex2 = __commonJS({
     };
     module2.exports = Duplex;
     var Readable = require_stream_readable2();
-    var Writable = require_stream_writable2();
+    var Writable2 = require_stream_writable2();
     require_inherits()(Duplex, Readable);
     {
-      keys = objectKeys(Writable.prototype);
+      keys = objectKeys(Writable2.prototype);
       for (v = 0; v < keys.length; v++) {
         method = keys[v];
-        if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+        if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable2.prototype[method];
       }
     }
     var keys;
@@ -19075,7 +19077,7 @@ var require_stream_duplex2 = __commonJS({
     function Duplex(options) {
       if (!(this instanceof Duplex)) return new Duplex(options);
       Readable.call(this, options);
-      Writable.call(this, options);
+      Writable2.call(this, options);
       this.allowHalfOpen = true;
       if (options) {
         if (options.readable === false) this.readable = false;
@@ -19545,15 +19547,15 @@ var require_async_iterator = __commonJS({
       var key = _toPrimitive(arg, "string");
       return typeof key === "symbol" ? key : String(key);
     }
-    function _toPrimitive(input2, hint) {
-      if (typeof input2 !== "object" || input2 === null) return input2;
-      var prim = input2[Symbol.toPrimitive];
+    function _toPrimitive(input, hint) {
+      if (typeof input !== "object" || input === null) return input;
+      var prim = input[Symbol.toPrimitive];
       if (prim !== void 0) {
-        var res = prim.call(input2, hint || "default");
+        var res = prim.call(input, hint || "default");
         if (typeof res !== "object") return res;
         throw new TypeError("@@toPrimitive must return a primitive value.");
       }
-      return (hint === "string" ? String : Number)(input2);
+      return (hint === "string" ? String : Number)(input);
     }
     var finished = require_end_of_stream();
     var kLastResolve = Symbol("lastResolve");
@@ -19777,15 +19779,15 @@ var require_from = __commonJS({
       var key = _toPrimitive(arg, "string");
       return typeof key === "symbol" ? key : String(key);
     }
-    function _toPrimitive(input2, hint) {
-      if (typeof input2 !== "object" || input2 === null) return input2;
-      var prim = input2[Symbol.toPrimitive];
+    function _toPrimitive(input, hint) {
+      if (typeof input !== "object" || input === null) return input;
+      var prim = input[Symbol.toPrimitive];
       if (prim !== void 0) {
-        var res = prim.call(input2, hint || "default");
+        var res = prim.call(input, hint || "default");
         if (typeof res !== "object") return res;
         throw new TypeError("@@toPrimitive must return a primitive value.");
       }
-      return (hint === "string" ? String : Number)(input2);
+      return (hint === "string" ? String : Number)(input);
     }
     var ERR_INVALID_ARG_TYPE = require_errors().codes.ERR_INVALID_ARG_TYPE;
     function from(Readable, iterable, opts) {
@@ -41850,10 +41852,10 @@ var require_lazystream = __commonJS({
     var PassThrough = require_passthrough();
     module2.exports = {
       Readable,
-      Writable
+      Writable: Writable2
     };
     util.inherits(Readable, PassThrough);
-    util.inherits(Writable, PassThrough);
+    util.inherits(Writable2, PassThrough);
     function beforeFirstCall(instance, method, callback) {
       instance[method] = function() {
         delete instance[method];
@@ -41873,9 +41875,9 @@ var require_lazystream = __commonJS({
       });
       this.emit("readable");
     }
-    function Writable(fn, options) {
-      if (!(this instanceof Writable))
-        return new Writable(fn, options);
+    function Writable2(fn, options) {
+      if (!(this instanceof Writable2))
+        return new Writable2(fn, options);
       PassThrough.call(this, options);
       beforeFirstCall(this, "_write", function() {
         var destination = fn.call(this, options);
@@ -47028,17 +47030,17 @@ var require_buffer_crc32 = __commonJS({
     if (typeof Int32Array !== "undefined") {
       CRC_TABLE = new Int32Array(CRC_TABLE);
     }
-    function ensureBuffer(input2) {
-      if (Buffer2.isBuffer(input2)) {
-        return input2;
+    function ensureBuffer(input) {
+      if (Buffer2.isBuffer(input)) {
+        return input;
       }
       var hasNewBufferAPI = typeof Buffer2.alloc === "function" && typeof Buffer2.from === "function";
-      if (typeof input2 === "number") {
-        return hasNewBufferAPI ? Buffer2.alloc(input2) : new Buffer2(input2);
-      } else if (typeof input2 === "string") {
-        return hasNewBufferAPI ? Buffer2.from(input2) : new Buffer2(input2);
+      if (typeof input === "number") {
+        return hasNewBufferAPI ? Buffer2.alloc(input) : new Buffer2(input);
+      } else if (typeof input === "string") {
+        return hasNewBufferAPI ? Buffer2.from(input) : new Buffer2(input);
       } else {
-        throw new Error("input must be buffer, number, or string, received " + typeof input2);
+        throw new Error("input must be buffer, number, or string, received " + typeof input);
       }
     }
     function bufferizeInt(num) {
@@ -48591,7 +48593,7 @@ var require_extract = __commonJS({
     var util = require("util");
     var bl = require_bl();
     var headers = require_headers();
-    var Writable = require_readable2().Writable;
+    var Writable2 = require_readable2().Writable;
     var PassThrough = require_readable2().PassThrough;
     var noop = function() {
     };
@@ -48622,7 +48624,7 @@ var require_extract = __commonJS({
     };
     var Extract = function(opts) {
       if (!(this instanceof Extract)) return new Extract(opts);
-      Writable.call(this, opts);
+      Writable2.call(this, opts);
       opts = opts || {};
       this._offset = 0;
       this._buffer = bl();
@@ -48746,7 +48748,7 @@ var require_extract = __commonJS({
       this._onheader = onheader;
       this._parse(512, onheader);
     };
-    util.inherits(Extract, Writable);
+    util.inherits(Extract, Writable2);
     Extract.prototype.destroy = function(err) {
       if (this._destroyed) return;
       this._destroyed = true;
@@ -48899,7 +48901,7 @@ var require_pack = __commonJS({
     var inherits2 = require_inherits();
     var alloc = Buffer.alloc;
     var Readable = require_readable2().Readable;
-    var Writable = require_readable2().Writable;
+    var Writable2 = require_readable2().Writable;
     var StringDecoder = require("string_decoder").StringDecoder;
     var headers = require_headers();
     var DMODE = parseInt("755", 8);
@@ -48927,12 +48929,12 @@ var require_pack = __commonJS({
       return "file";
     }
     var Sink = function(to) {
-      Writable.call(this);
+      Writable2.call(this);
       this.written = 0;
       this._to = to;
       this._destroyed = false;
     };
-    inherits2(Sink, Writable);
+    inherits2(Sink, Writable2);
     Sink.prototype._write = function(data, enc, cb) {
       this.written += data.length;
       if (this._to.push(data)) return cb();
@@ -48944,12 +48946,12 @@ var require_pack = __commonJS({
       this.emit("close");
     };
     var LinkSink = function() {
-      Writable.call(this);
+      Writable2.call(this);
       this.linkname = "";
       this._decoder = new StringDecoder("utf-8");
       this._destroyed = false;
     };
-    inherits2(LinkSink, Writable);
+    inherits2(LinkSink, Writable2);
     LinkSink.prototype._write = function(data, enc, cb) {
       this.linkname += this._decoder.write(data);
       cb();
@@ -48960,10 +48962,10 @@ var require_pack = __commonJS({
       this.emit("close");
     };
     var Void = function() {
-      Writable.call(this);
+      Writable2.call(this);
       this._destroyed = false;
     };
-    inherits2(Void, Writable);
+    inherits2(Void, Writable2);
     Void.prototype._write = function(data, enc, cb) {
       cb(new Error("No body allowed for this entry"));
     };
@@ -51087,8 +51089,8 @@ var require_binary = __commonJS({
       }
       return s;
     };
-    exports2.stream = function(input2) {
-      if (input2) return exports2.apply(null, arguments);
+    exports2.stream = function(input) {
+      if (input) return exports2.apply(null, arguments);
       var pending = null;
       function getBytes(bytes, cb, skip) {
         pending = {
@@ -54486,19 +54488,19 @@ var require_using = __commonJS({
         if (typeof fn !== "function") {
           return apiRejection("expecting a function but got " + util.classString(fn));
         }
-        var input2;
+        var input;
         var spreadArgs = true;
         if (len === 2 && Array.isArray(arguments[0])) {
-          input2 = arguments[0];
-          len = input2.length;
+          input = arguments[0];
+          len = input.length;
           spreadArgs = false;
         } else {
-          input2 = arguments;
+          input = arguments;
           len--;
         }
         var resources = new ResourceList(len);
         for (var i = 0; i < len; ++i) {
-          var resource = input2[i];
+          var resource = input[i];
           if (Disposer.isDisposer(resource)) {
             var disposer = resource;
             resource = resource.promise();
@@ -56933,8 +56935,8 @@ var require_duplexer2 = __commonJS({
       }
     }
     DuplexWrapper.prototype = Object.create(stream.Duplex.prototype, { constructor: { value: DuplexWrapper } });
-    DuplexWrapper.prototype._write = function _write(input2, encoding, done) {
-      this._writable.write(input2, encoding, done);
+    DuplexWrapper.prototype._write = function _write(input, encoding, done) {
+      this._writable.write(input, encoding, done);
     };
     DuplexWrapper.prototype._read = function _read() {
       var buf;
@@ -61381,9 +61383,9 @@ var require_workbook_reader = __commonJS({
     var HyperlinkReader = require_hyperlink_reader();
     tmp.setGracefulCleanup();
     var WorkbookReader = class extends EventEmitter {
-      constructor(input2, options = {}) {
+      constructor(input, options = {}) {
         super();
-        this.input = input2;
+        this.input = input;
         this.options = {
           worksheets: "emit",
           sharedStrings: "cache",
@@ -61395,18 +61397,18 @@ var require_workbook_reader = __commonJS({
         this.styles = new StyleManager();
         this.styles.init();
       }
-      _getStream(input2) {
-        if (input2 instanceof nodeStream.Readable || input2 instanceof Readable) {
-          return input2;
+      _getStream(input) {
+        if (input instanceof nodeStream.Readable || input instanceof Readable) {
+          return input;
         }
-        if (typeof input2 === "string") {
-          return fs.createReadStream(input2);
+        if (typeof input === "string") {
+          return fs.createReadStream(input);
         }
-        throw new Error(`Could not recognise input: ${input2}`);
+        throw new Error(`Could not recognise input: ${input}`);
       }
-      async read(input2, options) {
+      async read(input, options) {
         try {
-          for await (const { eventType, value } of this.parse(input2, options)) {
+          for await (const { eventType, value } of this.parse(input, options)) {
             switch (eventType) {
               case "shared-strings":
                 this.emit(eventType, value);
@@ -61433,9 +61435,9 @@ var require_workbook_reader = __commonJS({
           }
         }
       }
-      async *parse(input2, options) {
+      async *parse(input, options) {
         if (options) this.options = options;
-        const stream = this.stream = this._getStream(input2 || this.input);
+        const stream = this.stream = this._getStream(input || this.input);
         const zip = unzip.Parse({ forceStream: true });
         stream.pipe(zip);
         const waitingWorkSheets = [];
@@ -61933,25 +61935,25 @@ var require_providers = __commonJS({
         officialDocumentationUrl: "https://developer.intuit.com/app/developer/qbo/docs/develop/authentication-and-authorization/oauth-2.0"
       }
     ];
-    async function fetchProviderTransactions(input2) {
-      validateDateRange(input2.startDate, input2.endDate);
-      const capability = requireCapability(input2.provider);
-      const output2 = [];
+    async function fetchProviderTransactions(input) {
+      validateDateRange(input.startDate, input.endDate);
+      const capability = requireCapability(input.provider);
+      const output = [];
       let page = 1;
       let startPosition = 1;
       let nextUrl = null;
       do {
-        const url = nextUrl ?? buildProviderPageUrl(capability, input2, page, startPosition);
-        const response = await requestWithRetry(input2.transport, { url, headers: providerHeaders(input2) }, input2.signal, input2.wait);
-        const parsed = parseProviderPage(input2.provider, response.body, input2.organizationCurrency);
-        output2.push(...parsed.transactions);
+        const url = nextUrl ?? buildProviderPageUrl(capability, input, page, startPosition);
+        const response = await requestWithRetry(input.transport, { url, headers: providerHeaders(input) }, input.signal, input.wait);
+        const parsed = parseProviderPage(input.provider, response.body, input.organizationCurrency);
+        output.push(...parsed.transactions);
         nextUrl = parsed.nextUrl;
         page += 1;
         startPosition += parsed.pageSize;
         if (page > 1e3)
           throw new Error("Accounting provider pagination exceeded the safe page limit.");
-      } while (nextUrl || shouldContinueProviderPagination(input2.provider, output2.length, page - 1));
-      return output2;
+      } while (nextUrl || shouldContinueProviderPagination(input.provider, output.length, page - 1));
+      return output;
     }
     function requireCapability(provider) {
       const capability = exports2.ACCOUNTING_PROVIDER_CAPABILITIES.find((candidate) => candidate.provider === provider);
@@ -61974,20 +61976,20 @@ var require_providers = __commonJS({
       }
       throw new Error("Accounting provider request failed.");
     }
-    function buildProviderPageUrl(capability, input2, page, startPosition) {
-      if (input2.provider === "xero")
-        return capability.apiBaseUrl + "/BankTransactions?page=" + page + "&where=" + encodeURIComponent("Date >= DateTime(" + input2.startDate.replaceAll("-", ",") + ") && Date <= DateTime(" + input2.endDate.replaceAll("-", ",") + ")");
-      if (input2.provider === "myob")
-        return capability.apiBaseUrl + "/" + encodeURIComponent(input2.organizationId) + "/Banking/SpendMoneyTxn?$filter=" + encodeURIComponent("Date ge datetime'" + input2.startDate + "' and Date le datetime'" + input2.endDate + "'") + "&$top=400&$skip=" + (page - 1) * 400;
-      const query = "select * from Purchase where TxnDate >= '" + input2.startDate + "' and TxnDate <= '" + input2.endDate + "' startposition " + startPosition + " maxresults 1000";
-      return capability.apiBaseUrl + "/" + encodeURIComponent(input2.organizationId) + "/query?minorversion=75&query=" + encodeURIComponent(query);
-    }
-    function providerHeaders(input2) {
-      if (input2.provider === "xero")
-        return { Authorization: "Bearer " + input2.accessToken, "Xero-tenant-id": input2.organizationId, Accept: "application/json" };
-      if (input2.provider === "myob")
-        return { Authorization: "Bearer " + input2.accessToken, Accept: "application/json", "x-myobapi-version": "v2" };
-      return { Authorization: "Bearer " + input2.accessToken, Accept: "application/json" };
+    function buildProviderPageUrl(capability, input, page, startPosition) {
+      if (input.provider === "xero")
+        return capability.apiBaseUrl + "/BankTransactions?page=" + page + "&where=" + encodeURIComponent("Date >= DateTime(" + input.startDate.replaceAll("-", ",") + ") && Date <= DateTime(" + input.endDate.replaceAll("-", ",") + ")");
+      if (input.provider === "myob")
+        return capability.apiBaseUrl + "/" + encodeURIComponent(input.organizationId) + "/Banking/SpendMoneyTxn?$filter=" + encodeURIComponent("Date ge datetime'" + input.startDate + "' and Date le datetime'" + input.endDate + "'") + "&$top=400&$skip=" + (page - 1) * 400;
+      const query = "select * from Purchase where TxnDate >= '" + input.startDate + "' and TxnDate <= '" + input.endDate + "' startposition " + startPosition + " maxresults 1000";
+      return capability.apiBaseUrl + "/" + encodeURIComponent(input.organizationId) + "/query?minorversion=75&query=" + encodeURIComponent(query);
+    }
+    function providerHeaders(input) {
+      if (input.provider === "xero")
+        return { Authorization: "Bearer " + input.accessToken, "Xero-tenant-id": input.organizationId, Accept: "application/json" };
+      if (input.provider === "myob")
+        return { Authorization: "Bearer " + input.accessToken, Accept: "application/json", "x-myobapi-version": "v2" };
+      return { Authorization: "Bearer " + input.accessToken, Accept: "application/json" };
     }
     function parseProviderPage(provider, body, defaultCurrency) {
       if (provider === "xero") {
@@ -62019,8 +62021,8 @@ var require_providers = __commonJS({
       const currency = asRecord(item.CurrencyRef);
       return normalized({ provider: "quickbooks", id: stringValue(item.Id), merchant: stringValue(entity.name) || "Unknown QuickBooks entity", date: dateValue(item.TxnDate), amount: numberValue(item.TotalAmt), currency: stringValue(currency.value) || defaultCurrency, category: stringValue(account.name) || null, reference: [stringValue(item.PrivateNote), stringValue(item.PaymentType)], reconciled: "unknown" });
     }
-    function normalized(input2) {
-      return { transactionIdHash: (0, node_crypto_1.createHash)("sha256").update(input2.provider + "\0" + input2.id).digest("hex"), merchantIdentity: input2.merchant, transactionDate: input2.date, amountMinor: Math.round(input2.amount * 100), currency: input2.currency.toUpperCase(), sourceAccountClass: "bank", accountingCategory: input2.category, referenceFragments: input2.reference.filter(Boolean).map(safeFragment).slice(0, 4), reconciliationState: input2.reconciled, evidenceSource: input2.provider };
+    function normalized(input) {
+      return { transactionIdHash: (0, node_crypto_1.createHash)("sha256").update(input.provider + "\0" + input.id).digest("hex"), merchantIdentity: input.merchant, transactionDate: input.date, amountMinor: Math.round(input.amount * 100), currency: input.currency.toUpperCase(), sourceAccountClass: "bank", accountingCategory: input.category, referenceFragments: input.reference.filter(Boolean).map(safeFragment).slice(0, 4), reconciliationState: input.reconciled, evidenceSource: input.provider };
     }
     function shouldContinueProviderPagination(provider, total, pageCount) {
       if (provider === "xero")
@@ -62145,15 +62147,17 @@ When the source manifest is absent or has **GATHERING** status:
 
 - Always use the same progressive opening, whether source files already exist or not. Ask exactly one question at a time and wait for its answer before asking the next:
   1. **Do you have an existing website, product, or repository I should understand?** Accept a URL, path, short description, or \u201Cno.\u201D
-  2. **In one sentence, what is the main problem and who are we solving it for?**
-  3. **What software or integrations are involved today?** Accept \u201Cnone\u201D or \u201Cnot sure.\u201D
+  2. **Briefly, what is the main problem, who experiences it, and what outcome would make this work worthwhile?**
+  3. **What software or integrations are involved today, and are any required to stay, specifically intended for replacement, or open to consolidation?** Accept \u201Cnone\u201D or \u201Cnot sure.\u201D
   4. **How would you like me to work?** Offer the three discovery depths below.
   5. **${accounting_discovery_1.ACCOUNTING_DISCOVERY_QUESTION}** If yes, offer local CSV/XLSX export first and only supported, enabled browser providers. Before either path, explain the processing, temporary-data, configured AI-provider, Git-report, cleanup, and revocation boundaries truthfully. If no, cancelled, unsupported, or authorization fails, record only that the optional branch was not used and continue ordinary discovery.
 - Do not display all five questions in the first response and do not ask the owner to answer them as a form.
 - Keep the first response short: explain that discovery starts with five brief questions asked one at a time, then ask question one only.
 - Create **docs/discovery/sources/owner-interview.md** when the first answer arrives. After each answer, append it with the date, then distribute the useful meaning into every affected curated document as **DRAFT** material. One answer may update several documents; do not wait until a later document-specific interview. Preserve what the owner actually said separately from AI inference.
-- After question five and any optional spend-analysis branch, ask the owner to copy any useful Markdown or text material into **docs/discovery/sources/** and reply **gathering is complete** when ready. Explain briefly that requirements, process notes, policies, research, system notes, contracts, standards, manuals, spreadsheets, presentations, and prior decisions can help.
-- Explain only the source rules needed at that moment: raw material remains local and is ignored by Git by default; exclude credentials, secrets, unnecessary personal or regulated information, and material the owner cannot process; difficult binary material needs a Markdown sidecar.
+- For question three, record each material product or channel with an owner-evidenced disposition: **REQUIRED_TO_STAY**, **REPLACE**, **OPEN_TO_CONSOLIDATION**, **TRANSITIONAL_OR_FALLBACK**, or **UNDECIDED**. Mentioning a current product proves only that it exists; never infer that it should remain. If the owner provides a list without future intent, preserve every disposition as **UNDECIDED** and resolve only the materially consequential choices by targeted exception during synthesis.
+- After question five and any optional spend-analysis branch, clearly invite the owner to add as much relevant source material as they can readily find and are comfortable allowing the configured AI to process. Ask them to paste notes as Markdown or text or copy existing documents into **docs/discovery/sources/**. Tell them not to organize, rename, summarize, deduplicate, or decide what matters: SwarmCraft will inventory the collection, identify duplicates and contradictions, flag unsupported or sensitive content, and propose one useful source set for aggregate confirmation.
+- Give concrete examples: requirements, process notes, policies, procedures, proposals, research, system documentation, contracts, standards, manuals, spreadsheets, presentations, reports, stakeholder notes, screenshots, and prior decisions. Explain that drafts and conflicting versions are useful when their status is clear. Ask the owner to reply **gathering is complete** after adding everything they are comfortable providing, even when they have nothing else.
+- Explain only the source rules needed at that moment: files stay in the local workspace and are ignored by Git by default; the SwarmCraft product does not directly upload the source directory, but the configured AI may read and process its contents during discovery; exclude credentials, secrets, unnecessary personal or regulated information, and material the owner is not permitted to process; difficult binary material needs a Markdown sidecar.
 - Pause until the owner says **gathering is complete**, even when they have no additional material. Then inventory the interview record and any supplied sources together.
 
 ## Checkpoint progress as you go
@@ -62229,8 +62233,13 @@ Treat the nine curated documents as one coverage map, not nine consecutive inter
 - In **goals-and-success.md**, propose a short plain-language **projectTitle** in frontmatter and include it in whole-document review. Do not use a digest, workspace folder, or generic "Deep Discovery project" label as the owner-facing name.
 - Preserve stable source paths, section/page anchors, and digests. Preserve raw sources and sidecars unless the owner explicitly asks for an edit.
 - Draft a coherent proposed understanding across goals, roles, workflows, records and rules, integrations, experience, quality and operations, risks and decisions, and acceptance. Present the recommended direction in concise owner language, with alternatives only where a material fork exists.
+- Before fixing the target shape, reconcile a product-disposition matrix across **goals-and-success.md**, **domain-data-and-rules.md**, **integrations-and-boundaries.md**, and **decisions-risks-and-open-questions.md**. Distinguish owner-confirmed dispositions from recommendations and unresolved choices. If an undecided product could materially change whether the outcome is orchestration, selective replacement, consolidation, or staged transition, ask one grouped exception question and keep affected documents out of **REVIEWED** until answered.
 - Do the initial thinking for the owner. Ask what is incorrect, missing, unsafe, or materially different rather than asking the owner to originate every role, rule, status, exception, or measure.
-- For **Recommend, then refine**, invoke **${provider === "codex" ? "$swarmcraft-prototype" : "/prototype"}** after the initial synthesis and no more than one focused clarification round. Build the smallest useful branded flow that exposes the main workflow and its important authority, safety, failure, or recovery decision. Balanced and detail-first discovery may resolve more high-impact boundaries first, but must not revert to a document-by-document questionnaire.
+- For **Recommend, then refine**, invoke **${provider === "codex" ? "$swarmcraft-prototype" : "/prototype"}** after the initial synthesis and no more than one focused clarification round. Start with the smallest useful branded flow that exposes the primary workflow and its important authority, safety, failure, or recovery decision. Balanced and detail-first discovery may resolve more high-impact boundaries first, but must not revert to a document-by-document questionnaire.
+- After each prototype review, perform a prototype-coverage check across independently meaningful user or operator journeys, materially different roles and authority boundaries, consequential safety or payment decisions, exception and recovery paths, offline or degraded operation, and interaction-heavy integration failures. Do not proceed to consolidation merely because one prototype exists.
+- Extend the current prototype when remaining scenarios share the same product shell, actors, interaction model, and decision context. Invoke **${provider === "codex" ? "$swarmcraft-prototype" : "/prototype"}** again to create another focused prototype when combining a distinct role, operating context, workflow, or recovery model would obscure the decisions being reviewed. Preserve and link every reviewed prototype.
+- Use no fixed prototype count. Stop when material interaction uncertainty is experienceable and owner-corrected, already clear from evidence and prose, or explicitly recorded as delivery-stage validation because a disposable prototype cannot resolve it. Do not prototype routine screens or implementation detail merely for completeness.
+- Before Stage 4, record a concise prototype-coverage summary in **sources/owner-interview.md** and affected curated documents: each prototype path and decision scope, important scenarios covered, material areas intentionally handled in prose, deferred validation with rationale, and why the combined evidence is sufficient for discovery. A material gap that could change what is built remains discovery work.
 - Ask follow-up questions only for owner corrections, contradictions, genuine blockers, or high-impact safety, security, privacy, authority, payment, compliance, destructive migration, and observable acceptance boundaries. Group related questions and do not ask what the evidence or accepted proposal already answers.
 - Identify gaps, assumptions, risks, deferrals, exclusions, and not-applicable areas internally and in the curated documents. Do not burden the owner with a separate visible assumption ledger when a clear proposed direction and exception-based review can resolve it.
 - When a prototype is reviewed, copy its accepted meaning into every affected curated document so they remain complete without the local artifact. Keep prototype code and images under **docs/prototypes/** as local review aids; they do not enter the text-only Discovery Package automatically.
@@ -62245,18 +62254,20 @@ The first proposed direction should cover, in plain language: desired outcome an
 
 ## Stage 4: consolidate and review
 
-Use the confirmed direction and prototype corrections to update every affected curated document before asking for final review:
+Use the confirmed direction and prototype corrections to update every affected curated document before completing aggregate review:
 
 - Present one concise review map across all nine documents: the proposed outcome, roles, workflow, records, integrations, experience, operating constraints, material risks, acceptance direction, unresolved questions, and any proposed **NOT_APPLICABLE** document.
-- Do not run a new questionnaire for each document. Let the owner accept the listed direction as a whole, request corrections, identify an exception, or ask to inspect any document in detail.
-- Make all nine full documents available for inspection. An explicit aggregate acceptance may review several named documents at once only when their material contents were represented in the review map and the owner was told exactly which documents would be accepted.
+- Do not run a new questionnaire for each document or finish with a blanket request to accept all nine. Present the completed discovery record, invite corrections by exception, and let the owner ask to inspect any document in detail.
+- Make all nine full documents available for inspection. Name the documents covered by the review map, but do not describe them as **awaiting acceptance** when their material contents were already presented and the owner has explicitly directed the work to continue.
 - Summarize important content under confirmed material, open questions, deferrals, exclusions, not-applicable scope, and high-impact concerns without requiring the owner to manage an assumption inventory.
 - Visibly call out unresolved core workflow, security, privacy, compliance, destructive migration, payment, and acceptance issues.
 - Distinguish **Discovery blockers** from **delivery or launch gates**. A discovery blocker means the owner cannot yet define what must be built or how a high-impact concern can be handled safely. A delivery or launch gate describes implementation or evidence that the future project must complete and does not by itself set **criticalUnresolved: true**.
-- Ask the owner to accept the presented direction as an accurate current record, request changes, or leave the affected documents in draft.
-- When a reviewed prototype informed the document, summarize its firm decisions, adaptable direction, rejected alternatives, and unresolved questions in the document before asking for whole-document review. A prototype walkthrough does not replace document review.
+- Treat a prior explicit instruction such as **Continue with this direction**, plus the owner's subsequent corrections by exception, as aggregate review evidence for material that was actually visible in the proposal, prototype review, corrections, and final review map. If the final map introduces no new material decision, hidden extrapolation, unresolved owner question, or discovery blocker, set the covered documents to **REVIEWED**, create their scoped checkpoints, state that discovery is complete, and invite corrections without asking for another confirmation.
+- When the final map introduces a material decision that the owner has not seen, a proposed **NOT_APPLICABLE** disposition without owner rationale, or an unresolved high-impact exception, keep only the affected documents **READY_FOR_REVIEW** and ask one targeted exception question. Do not hold unrelated documents behind that question.
+- If no earlier explicit direction exists, ask once for corrections or an instruction to continue with the presented direction. Silence alone is not review evidence.
+- When a reviewed prototype informed the document, summarize its firm decisions, adaptable direction, rejected alternatives, and unresolved questions before concluding aggregate review or asking a targeted exception question. A prototype walkthrough alone does not replace document review.
 - Whole-document review confirms that each presented outcome is represented accurately; it does not turn hidden extrapolations or unresolved items into facts.
-- After explicit review, set each accepted document to **REVIEWED**, record **reviewedAt**, and write a concise owner-review summary identifying the proposal and corrections reviewed. Use **NOT_APPLICABLE** only with explicit owner rationale and review time.
+- After sufficient aggregate or targeted review evidence, set each covered document to **REVIEWED**, record **reviewedAt**, and write a concise owner-review summary identifying the proposal, explicit continuation, review map, and corrections reviewed. Use **NOT_APPLICABLE** only with explicit owner rationale and review time.
 - After writing each **REVIEWED** or **NOT_APPLICABLE** document, create one local Git checkpoint for that exact curated document with \`git commit --only -m "SwarmCraft: Review <filename>" -- docs/discovery/<filename>\`. Even when several documents were accepted together, create separate exact-path checkpoints. Never add raw sources, another discovery document, generated state, or unrelated repository work, and never push. If a document has no change, do not create an empty commit. If the checkpoint fails, preserve the reviewed file and tell the owner what Git needs; do not broaden the commit or change semantic outcomes to make it succeed.
 - Any later material edit returns the document to **DRAFT** or **READY_FOR_REVIEW** and clears the old review time.
 
@@ -62280,7 +62291,7 @@ Use the swarmcraft-discover skill. Detect the current discovery stage, explain t
     function renderDiscoveryGuide() {
       return `# Deep Discovery
 
-These files are the owner-and-agent working surface before SwarmCraft creates a project board. They are not the Discovery Package transport schema or the private seven-slice compiler.
+These files are the owner-and-agent working surface before SwarmCraft creates a project board. They are not the Discovery Package transport schema or the private server-side catalogue compiler.
 
 ## Start here
 
@@ -62289,10 +62300,10 @@ These files are the owner-and-agent working surface before SwarmCraft creates a
 
 ## Journey
 
-1. **Answer five brief opening questions.** The discover assistant always asks, one at a time, about existing website/product/repository context, the main problem and intended user, current software or integrations, how you want it to work, and whether you want optional SaaS-spend evidence. Each answer is recorded and distributed into every affected discovery-document draft as you go.
-2. **Add sources and confirm gathering.** Copy any useful Markdown or text material into **sources/**, then say **gathering is complete** even when you have nothing else to add. For PDF and other difficult formats, keep the original and create a same-named Markdown sidecar using the source guidance. The assistant inventories the interview record and supplied material, asks for one aggregate source-set confirmation, and creates a local Git checkpoint containing only that manifest.
-3. **Review a proposed direction and early prototype.** The assistant researches owner-authorized context, drafts a recommendation across all nine discovery areas, and asks you to correct it by exception. The recommended **Recommend, then refine** route builds a small disposable prototype after at most one focused clarification round. Open its \`README.md\` in Markdown Preview and right-click \`index.html\` to **Open in Integrated Browser** so you can review both side by side.
-4. **Consolidate and review.** Prototype corrections flow into every affected document. The assistant presents one concise review map rather than interviewing through each file, while all nine full documents remain available for inspection. Explicit acceptance applies only to material actually presented. Each accepted document receives its own local Git checkpoint; the assistant does not push.
+1. **Answer five brief opening questions.** The discover assistant always asks, one at a time, about existing website/product/repository context; the problem, affected people, and desired outcome; current software and whether it must stay, should be replaced, or is open to consolidation; how you want discovery to work; and whether you want optional SaaS-spend evidence. Each answer is recorded and distributed into every affected discovery-document draft as you go.
+2. **Add sources and confirm gathering.** Add as much relevant source material as you can readily find and are comfortable allowing the configured AI to process. Paste notes as Markdown or text or copy existing documents into **sources/**; you do not need to organize, rename, summarize, deduplicate, or decide what matters. Drafts and conflicting versions are useful when their status is clear. The assistant inventories the collection, identifies duplicates and contradictions, flags unsupported or sensitive content, and proposes one useful source set for aggregate confirmation. For PDF and other difficult formats, keep the original and create a same-named Markdown sidecar using the source guidance. Say **gathering is complete** after adding everything you are comfortable providing, even when you have nothing else. The assistant creates a local Git checkpoint containing only the confirmed manifest.
+3. **Review a proposed direction and focused prototypes.** The assistant researches owner-authorized context, drafts a recommendation across all nine discovery areas, and asks you to correct it by exception. The recommended **Recommend, then refine** route starts with one small disposable prototype after at most one focused clarification round, then checks whether materially different roles, workflows, authority boundaries, or failure and recovery experiences need another focused prototype. Related scenarios extend the existing prototype; distinct experiences remain separate. Open each \`README.md\` in Markdown Preview and right-click its \`index.html\` to **Open in Integrated Browser** so you can review both side by side.
+4. **Consolidate and review.** Prototype corrections flow into every affected document. The assistant presents one concise review map rather than interviewing through each file, while all nine full documents remain available for inspection. If you already explicitly continued with the presented direction and the map adds no new material decision, the assistant completes review and invites corrections by exception instead of asking you to accept all nine again. Each reviewed document receives its own local Git checkpoint; the assistant does not push.
 5. **Prepare only when ready.** All nine documents must be **REVIEWED** or explicitly **NOT_APPLICABLE**, selected sidecars must be current, and missing owner knowledge must not prevent a safe, coherent project definition. A recommended visual comparison remains visible in the sidebar but does not block preparation. Future implementation work and launch evidence belong in the reviewed documents and do not have to exist before preparation.
 
 ## Curated coverage map
@@ -62309,7 +62320,7 @@ These files are the owner-and-agent working surface before SwarmCraft creates a
 
 Discovery can resume after any interruption. Human-authored files remain owner-controlled, and raw binary bodies are never uploaded in a Discovery Package.
 
-Every discovery uses the same opening whether documents already exist or not. The assistant asks the five questions one at a time, records the answers in **sources/owner-interview.md**, and uses each answer immediately across the relevant document drafts. The fifth branch is optional and returns cleanly to discovery when declined, cancelled, unsupported, or unsuccessful. After you finish adding any other sources and say **gathering is complete**, it uses the nine documents as a coverage map rather than a conversation script.
+Every discovery uses the same opening whether documents already exist or not. The assistant asks the five questions one at a time, records the answers in **sources/owner-interview.md**, and uses each answer immediately across the relevant document drafts. Current products remain dispositionally undecided unless you say they must stay, should be replaced, are open to consolidation, or are transitional. The fifth branch is optional and returns cleanly to discovery when declined, cancelled, unsupported, or unsuccessful. After you finish adding any other sources and say **gathering is complete**, it uses the nine documents as a coverage map rather than a conversation script.
 `;
     }
     function renderCuratedDiscoveryDocument(title, prompt, includeProjectTitle = false) {
@@ -62347,9 +62358,11 @@ Record the owner's whole-document review summary here. Reviewing this document c
     function renderSourceGuide() {
       return `# Raw discovery sources
 
-Copy or paste existing source material here before synthesis. SwarmCraft does not upload this directory directly, and raw files are ignored by Git by default. Tell the discover assistant when gathering is complete; it will inventory the material and ask for one aggregate confirmation of the proposed source set.
+Add as much relevant source material as you can readily find and are comfortable allowing the configured AI to process. Paste notes as Markdown or text or copy existing documents here before synthesis. You do not need to organize, rename, summarize, deduplicate, or decide what matters. SwarmCraft will inventory the collection, identify duplicates and contradictions, flag unsupported or sensitive content, and propose one useful source set for aggregate confirmation.
+
+Useful inputs include requirements, process notes, policies, procedures, proposals, research, system documentation, contracts, standards, manuals, spreadsheets, presentations, reports, stakeholder notes, screenshots, and prior decisions. Drafts and conflicting versions are useful when their status is clear.
 
-Useful inputs include requirements, process notes, policies, proposals, user research, contracts, standards, manuals, spreadsheets, presentations, system notes, and existing decisions. Exclude credentials, secrets, unnecessary personal or regulated information, and material you are not permitted to process.
+Files stay in the local workspace and are ignored by Git by default. The SwarmCraft product does not directly upload this directory, but the configured AI may read and process its contents during discovery. Exclude credentials, secrets, unnecessary personal or regulated information, and material you are not permitted to process. Tell the discover assistant **gathering is complete** after adding everything you are comfortable providing, even when you have nothing else.
 
 ## PDF and difficult formats
 
@@ -62391,7 +62404,7 @@ var require_seedDiscoveryFiles = __commonJS({
     var renderDiscovery_1 = require_renderDiscovery();
     var renderPrototype_1 = require_renderPrototype();
     var renderReports_1 = require_renderReports();
-    exports2.DISCOVERY_SEED_VERSION = 5;
+    exports2.DISCOVERY_SEED_VERSION = 9;
     exports2.DISCOVERY_SEED_STATE_PATH = ".swarmcraft/discovery.seed-state.json";
     var curated = [
       ["goals-and-success.md", "Goals and success", "Capture desired outcomes, measurable success, boundaries, and why the work matters."],
@@ -62446,12 +62459,6 @@ var require_seedDiscoveryFiles = __commonJS({
       for (const file of files) {
         const exists = await dependencies.fileExists(file.relativePath);
         if (exists && file.ownership === "CREATE_ONCE_HUMAN") {
-          const current = await dependencies.readFile(file.relativePath);
-          const legacyHashes = legacyCreateOnceHashes(file.relativePath);
-          if ((previous?.seedVersion ?? 1) < exports2.DISCOVERY_SEED_VERSION && legacyHashes.includes(hash(current)) && current !== file.contents) {
-            await dependencies.writeFile(file.relativePath, file.contents);
-            result.written.push(file.relativePath);
-          }
           continue;
         }
         if (exists) {
@@ -62509,25 +62516,6 @@ var require_seedDiscoveryFiles = __commonJS({
     function hash(contents) {
       return (0, node_crypto_1.createHash)("sha256").update(contents, "utf8").digest("hex");
     }
-    function legacyCreateOnceHashes(relativePath) {
-      if (relativePath === "docs/discovery/README.md")
-        return [
-          "efe8dd9e59acc48cfef1b3d7397c69fc6bc635ffcc736d86fb276a09dc0b9876",
-          "b21d6412d5750395933c2e92dad09851a03e5a85cc74961ab8ad210acf412e0b",
-          "f86ac3f41439c57612112810783361fda8a9d280469d99ce05fab43072e75117"
-        ];
-      if (relativePath === "docs/discovery/sources/README.md")
-        return ["78480d822849225c02d0fe09b2ba9e6497112f90c203f3e77a55c5f3284a3172"];
-      const match = curated.find(([file]) => relativePath === `docs/discovery/${file}`);
-      return match ? [hash(`# ${match[1]}
-
-${match[2]}
-
-## Confirmed
-
-## Assumptions and open questions
-`)] : [];
-    }
   }
 });
 
@@ -62550,24 +62538,24 @@ var require_securityReportContract = __commonJS({
     function redactSecurityEvidence(value) {
       return value.replace(/\b(Bearer\s+)[A-Za-z0-9._~+\/-]+/gi, "$1[REDACTED]").replace(/\b(api[_-]?key|token|secret|password)\s*[:=]\s*[^\s,;]+/gi, "$1=[REDACTED]").replace(/[\r\n]+/g, " ").replace(/[`|]/g, " ").replace(/\s+/g, " ").trim().slice(0, 500);
     }
-    function updateSecurityAssessment(input2) {
-      if (input2.cancelled)
+    function updateSecurityAssessment(input) {
+      if (input.cancelled)
         throw new Error("Cancelled security analysis preserves the previous report.");
-      if (input2.status === "PARTIAL" && input2.current.length === 0)
+      if (input.status === "PARTIAL" && input.current.length === 0)
         throw new Error("A partial security report requires useful evidence.");
-      const accepted = new Map((input2.acceptedRisks ?? []).map((record) => {
+      const accepted = new Map((input.acceptedRisks ?? []).map((record) => {
         validateAcceptedRisk(record);
         return [record.findingId, record];
       }));
-      const previousById = new Map(input2.previous.map((finding) => [finding.id, finding]));
-      const findings = input2.current.map((evidence) => {
+      const previousById = new Map(input.previous.map((finding) => [finding.id, finding]));
+      const findings = input.current.map((evidence) => {
         const id = createSecurityFindingId(evidence.ruleId, evidence.affectedSurface);
         const state = accepted.has(id) ? "accepted-risk" : evidence.confidence === "low" ? "human-verification" : previousById.has(id) ? "continuing" : "new";
         return { ...evidence, id, evidence: redactSecurityEvidence(evidence.evidence), state };
       }).sort((left, right) => left.id.localeCompare(right.id));
       const currentIds = new Set(findings.map(({ id }) => id));
-      const resolved = input2.previous.filter(({ id, state }) => !currentIds.has(id) && state !== "false-positive").map((finding) => ({ ...finding, state: "resolved" }));
-      const fullBaseline = input2.mode === "baseline" ? renderBaseline(input2.assessedRef, findings) : input2.previousFullBaseline ?? "No full baseline has been recorded.";
+      const resolved = input.previous.filter(({ id, state }) => !currentIds.has(id) && state !== "false-positive").map((finding) => ({ ...finding, state: "resolved" }));
+      const fullBaseline = input.mode === "baseline" ? renderBaseline(input.assessedRef, findings) : input.previousFullBaseline ?? "No full baseline has been recorded.";
       return { findings, resolved, fullBaseline };
     }
     function securityCheckingDisposition(findings) {
@@ -63202,19 +63190,18 @@ __export(main_exports, {
   findCommand: () => findCommand,
   formatDiscoveryElapsed: () => formatDiscoveryElapsed,
   main: () => main,
-  parseArgs: () => parseArgs
+  parseArgs: () => parseArgs,
+  runAuthLogin: () => runAuthLogin
 });
 module.exports = __toCommonJS(main_exports);
-var import_promises9 = require("node:fs/promises");
+var import_promises10 = require("node:fs/promises");
 var import_node_path9 = __toESM(require("node:path"), 1);
-var import_promises10 = require("node:readline/promises");
-var import_node_process = require("node:process");
 var import_packet_workflow6 = __toESM(require_dist(), 1);
 
 // package.json
 var package_default = {
   name: "@swarmcraftai/cli",
-  version: "0.4.0",
+  version: "0.4.1",
   description: "Prepare repositories and run packet-based SwarmCraft agent workflows from the terminal.",
   license: "SEE LICENSE IN LICENSE.txt",
   type: "module",
@@ -63846,22 +63833,22 @@ function shellQuote(value) {
 
 // src/workflows/one-shot-board-sync.ts
 var import_packet_workflow3 = __toESM(require_dist(), 1);
-async function syncPacketFile(input2) {
+async function syncPacketFile(input) {
   const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const fileContents = await readWorkspaceFile(input2.workspacePath, input2.relativePacketPath);
+  const fileContents = await readWorkspaceFile(input.workspacePath, input.relativePacketPath);
   const parsedPacket = (0, import_packet_workflow3.parsePacketFile)(fileContents);
-  if (parsedPacket.frontmatter.projectId !== input2.project.id || parsedPacket.frontmatter.taskId !== input2.task.id) {
-    throw new Error(`Packet ${input2.relativePacketPath} does not belong to task ${input2.task.id}.`);
+  if (parsedPacket.frontmatter.projectId !== input.project.id || parsedPacket.frontmatter.taskId !== input.task.id) {
+    throw new Error(`Packet ${input.relativePacketPath} does not belong to task ${input.task.id}.`);
   }
-  if (parsedPacket.frontmatter.syncRevision !== input2.task.revision) {
-    throw new Error(`Packet ${input2.relativePacketPath} is stale; expected revision ${input2.task.revision}.`);
+  if (parsedPacket.frontmatter.syncRevision !== input.task.revision) {
+    throw new Error(`Packet ${input.relativePacketPath} is stale; expected revision ${input.task.revision}.`);
   }
-  const shapeProblem = (0, import_packet_workflow3.findChecklistShapeProblem)(input2.task.checklistItems, parsedPacket.sections.checklists);
+  const shapeProblem = (0, import_packet_workflow3.findChecklistShapeProblem)(input.task.checklistItems, parsedPacket.sections.checklists);
   if (shapeProblem) {
     throw new Error(shapeProblem.message);
   }
-  let currentBoard = input2.board;
-  let currentTask = input2.task;
+  let currentBoard = input.board;
+  let currentTask = input.task;
   let syncedChanges = 0;
   for (const checklistStage of import_packet_workflow3.CHECKLIST_STAGES) {
     const currentItems = (0, import_packet_workflow3.listChecklistItemsForStage)(currentTask.checklistItems, checklistStage);
@@ -63871,29 +63858,29 @@ async function syncPacketFile(input2) {
       if (currentItem.completed === parsedItem.completed) {
         continue;
       }
-      currentBoard = await input2.client.updateChecklistItem(input2.project.id, currentTask.id, currentItem.id, {
+      currentBoard = await input.client.updateChecklistItem(input.project.id, currentTask.id, currentItem.id, {
         completed: parsedItem.completed,
         expectedRevision: currentItem.revision
-      }, await input2.getAccessToken(), input2.delegationId);
+      }, await input.getAccessToken(), input.delegationId);
       currentTask = requireBoardTask(currentBoard, currentTask.id);
       syncedChanges += 1;
     }
   }
   const desiredNotes = (0, import_packet_workflow3.composeTaskNotes)(parsedPacket.sections.notes, parsedPacket.sections.agentUpdate);
   if ((currentTask.notes ?? null) !== desiredNotes) {
-    currentBoard = await input2.client.updateTaskNotes(input2.project.id, currentTask.id, {
+    currentBoard = await input.client.updateTaskNotes(input.project.id, currentTask.id, {
       notes: desiredNotes,
       expectedRevision: currentTask.revision
-    }, await input2.getAccessToken(), input2.delegationId);
+    }, await input.getAccessToken(), input.delegationId);
     currentTask = requireBoardTask(currentBoard, currentTask.id);
     syncedChanges += 1;
   }
-  if (input2.allowLaneSync && parsedPacket.frontmatter.lane !== currentTask.workflowState) {
-    currentBoard = await moveBoardTask(input2.client, await input2.getAccessToken(), input2.project.id, currentTask, parsedPacket.frontmatter.lane, input2.delegationId);
+  if (input.allowLaneSync && parsedPacket.frontmatter.lane !== currentTask.workflowState) {
+    currentBoard = await moveBoardTask(input.client, await input.getAccessToken(), input.project.id, currentTask, parsedPacket.frontmatter.lane, input.delegationId);
     currentTask = requireBoardTask(currentBoard, currentTask.id);
     syncedChanges += 1;
   }
-  await refreshPacketMetadata(input2.workspacePath, input2.relativePacketPath, currentTask, syncedAt);
+  await refreshPacketMetadata(input.workspacePath, input.relativePacketPath, currentTask, syncedAt);
   return { board: currentBoard, task: currentTask, syncedChanges };
 }
 async function moveBoardTask(client, accessToken, projectId, task, workflowState, delegationId) {
@@ -64947,6 +64934,46 @@ function findCommand(positionals) {
   return COMMANDS.find((command) => command.name === commandKey);
 }
 
+// src/terminalPrompt.ts
+var import_node_process = require("node:process");
+var import_promises9 = require("node:readline/promises");
+var import_node_stream = require("node:stream");
+var DEFAULT_STREAMS = { input: import_node_process.stdin, output: import_node_process.stdout };
+async function promptLine(prompt, streams = DEFAULT_STREAMS) {
+  const readline = (0, import_promises9.createInterface)({ input: streams.input, output: streams.output });
+  try {
+    return (await readline.question(prompt)).trim();
+  } finally {
+    readline.close();
+  }
+}
+async function promptSecret(prompt, streams = DEFAULT_STREAMS) {
+  if (!streams.input.isTTY) {
+    return promptLine(prompt, streams);
+  }
+  let muted = false;
+  const concealedOutput = new import_node_stream.Writable({
+    write(chunk, _encoding, callback) {
+      if (!muted) {
+        streams.output.write(chunk);
+      }
+      callback();
+    }
+  });
+  concealedOutput.isTTY = true;
+  concealedOutput.columns = streams.output.columns ?? 80;
+  const readline = (0, import_promises9.createInterface)({ input: streams.input, output: concealedOutput, terminal: true });
+  try {
+    const answer = readline.question(prompt);
+    muted = true;
+    return (await answer).trim();
+  } finally {
+    muted = false;
+    readline.close();
+    streams.output.write("\n");
+  }
+}
+
 // src/main.ts
 var VERSION = package_default.version;
 var DEFAULT_API_BASE_URL = "https://swarmcraft.ai/api";
@@ -65028,17 +65055,21 @@ ${command.summary}
 This command is planned but not implemented yet.`);
   }
 }
-async function runAuthLogin(parsed) {
+var DEFAULT_AUTH_LOGIN_PROMPTS = { line: promptLine, secret: promptSecret };
+async function runAuthLogin(parsed, prompts = DEFAULT_AUTH_LOGIN_PROMPTS) {
   const apiBaseUrl = getOption(parsed, "api-base-url") ?? process.env.SWARMCRAFT_API_BASE_URL ?? DEFAULT_API_BASE_URL;
-  const email = getOption(parsed, "email") ?? process.env.SWARMCRAFT_EMAIL ?? await promptLine("Email: ");
-  const password = getOption(parsed, "password") ?? process.env.SWARMCRAFT_PASSWORD ?? await promptSecret("Password: ");
+  const email = getOption(parsed, "email") ?? process.env.SWARMCRAFT_EMAIL ?? await prompts.line("Email: ");
+  const password = getOption(parsed, "password") ?? process.env.SWARMCRAFT_PASSWORD ?? await prompts.secret("Password: ");
   const client = new SwarmCraftClient(apiBaseUrl);
   let tokenResponse = await client.login(email, password);
   if (tokenResponse.user.mfaEnrolled && !tokenResponse.user.mfaVerified) {
-    const mfaCode = getOption(parsed, "mfa-code") ?? process.env.SWARMCRAFT_MFA_CODE;
-    const recoveryCode = getOption(parsed, "recovery-code") ?? process.env.SWARMCRAFT_MFA_RECOVERY_CODE;
+    let mfaCode = getOption(parsed, "mfa-code") ?? process.env.SWARMCRAFT_MFA_CODE;
+    let recoveryCode = getOption(parsed, "recovery-code") ?? process.env.SWARMCRAFT_MFA_RECOVERY_CODE;
     if (!mfaCode && !recoveryCode) {
-      throw new Error("MFA is required. Rerun with --mfa-code <code> or --recovery-code <code>.");
+      mfaCode = await prompts.secret("MFA code (press Enter to use a recovery code): ");
+      if (!mfaCode) {
+        recoveryCode = await prompts.secret("Recovery code: ");
+      }
     }
     const mfaResponse = recoveryCode ? await client.mfaRecovery(tokenResponse.accessToken, recoveryCode) : await client.mfaChallenge(tokenResponse.accessToken, mfaCode);
     tokenResponse = {
@@ -65346,7 +65377,7 @@ function parseOneShotOptions(parsed) {
   };
 }
 async function readRunManifest(workspacePath, runId) {
-  return JSON.parse(await (0, import_promises9.readFile)(resolveManifestPath(import_node_path9.default.resolve(workspacePath), runId), "utf8"));
+  return JSON.parse(await (0, import_promises10.readFile)(resolveManifestPath(import_node_path9.default.resolve(workspacePath), runId), "utf8"));
 }
 function printGeneralHelp() {
   console.log(`SwarmCraft CLI ${VERSION}
@@ -65427,17 +65458,6 @@ function parseRunId2(rawValue) {
   }
   return rawValue;
 }
-async function promptLine(prompt) {
-  const readline = (0, import_promises10.createInterface)({ input: import_node_process.stdin, output: import_node_process.stdout });
-  try {
-    return (await readline.question(prompt)).trim();
-  } finally {
-    readline.close();
-  }
-}
-async function promptSecret(prompt) {
-  return promptLine(prompt);
-}
 if (isCliEntrypoint()) {
   main(process.argv.slice(2)).then((exitCode) => {
     process.exitCode = exitCode;
@@ -65461,7 +65481,8 @@ function isCliEntrypoint() {
   findCommand,
   formatDiscoveryElapsed,
   main,
-  parseArgs
+  parseArgs,
+  runAuthLogin
 });
 /*! Bundled license information: