@hadooppei/hwcode 1.0.6 → 1.0.8

package/.pi/lib/runtime/paths.ts

@@ -5,6 +5,15 @@ export const HWCODE_DATA_DIRECTORY = ".hwcode";
 export const PROJECT_SDD_SPECS_RELATIVE = `${HWCODE_DATA_DIRECTORY}/specs`;
 export const PROJECT_CLOUD_RUNS_RELATIVE = `${HWCODE_DATA_DIRECTORY}/cloud/runs`;
 
+// Canonical subpath layout under ~/.hwcode. Kept together so filesystem topology
+// stays in one place instead of scattered across cloud/knowledge modules.
+const CLOUD_SUBDIR = "cloud";
+const CLOUD_VAULT_FILE = "credentials.enc";
+const CLOUD_KNOWN_HOSTS_FILE = "known_hosts";
+const CLOUD_TEMPLATES_SUBDIR = "templates";
+const CLOUD_TERRAFORM_SUBDIR = "terraform";
+const KNOWLEDGE_SUBDIR = "knowledge";
+
 export interface ProjectRuntimePaths {
   root: string;
   hwcode: string;
@@ -18,14 +27,19 @@ export interface UserRuntimePaths {
   cloud: string;
   cloudVault: string;
   cloudKnownHosts: string;
-  cloudPromptTemplates: string;
-  cloudDeploymentTemplates: string;
+  cloudTerraformTemplates: string;
+  knowledge: string;
+  knowledgeRules: string;
+  knowledgeTopics: string;
+  knowledgePending: string;
+  knowledgeCatalog: string;
+  knowledgeMemory: string;
 }
 
 export function projectRuntimePaths(projectRoot: string): ProjectRuntimePaths {
   const root = resolve(projectRoot);
   const hwcode = join(root, HWCODE_DATA_DIRECTORY);
-  const cloud = join(hwcode, "cloud");
+  const cloud = join(hwcode, CLOUD_SUBDIR);
   return {
     root,
     hwcode,
@@ -37,25 +51,23 @@ export function projectRuntimePaths(projectRoot: string): ProjectRuntimePaths {
 
 export function userRuntimePaths(home = homedir()): UserRuntimePaths {
   const root = join(home, HWCODE_DATA_DIRECTORY);
-  const cloud = join(root, "cloud");
+  const cloud = join(root, CLOUD_SUBDIR);
+  const knowledge = join(root, KNOWLEDGE_SUBDIR);
   return {
     root,
     cloud,
-    cloudVault: join(cloud, "credentials.enc"),
-    cloudKnownHosts: join(cloud, "known_hosts"),
-    cloudPromptTemplates: join(cloud, "templates", "prompts"),
-    cloudDeploymentTemplates: join(cloud, "templates", "deployments"),
+    cloudVault: join(cloud, CLOUD_VAULT_FILE),
+    cloudKnownHosts: join(cloud, CLOUD_KNOWN_HOSTS_FILE),
+    cloudTerraformTemplates: join(cloud, CLOUD_TEMPLATES_SUBDIR, CLOUD_TERRAFORM_SUBDIR),
+    knowledge,
+    knowledgeRules: join(knowledge, "rules"),
+    knowledgeTopics: join(knowledge, "topics"),
+    knowledgePending: join(knowledge, "pending"),
+    knowledgeCatalog: join(knowledge, "catalog.json"),
+    knowledgeMemory: join(knowledge, "MEMORY.md"),
   };
 }
 
-export function legacyUserCloudTemplatePaths(home = homedir()): {
-  prompts: string;
-  deployments: string;
-} {
-  const cloud = join(home, HWCODE_DATA_DIRECTORY, "cloud");
-  return { prompts: join(cloud, "prompts"), deployments: join(cloud, "templates") };
-}
-
 export function remoteRunnerPaths(user: string): { root: string; runs: string } {
   const root = posix.join("/home", user, HWCODE_DATA_DIRECTORY);
   return { root, runs: posix.join(root, "runs") };

package/.pi/lib/tool-result.ts

@@ -0,0 +1,7 @@
+export function toolError(message: string, details: Record<string, unknown> = {}) {
+  return { content: [{ type: "text" as const, text: message }], isError: true, details };
+}
+
+export function toolOk(message: string, details: Record<string, unknown> = {}) {
+  return { content: [{ type: "text" as const, text: message }], details };
+}

package/.pi/lib/workflows/cloud/bundles.ts

@@ -5,9 +5,8 @@ import { dirname, extname, isAbsolute, join, relative, sep } from "node:path";
 
 import { isCloudVendorId, type CloudVendorId } from "./providers.ts";
 import type { WorkflowState } from "../state.ts";
-import { legacyUserCloudTemplatePaths, userRuntimePaths } from "../../runtime/paths.ts";
+import { userRuntimePaths } from "../../runtime/paths.ts";
 import { CLOUD_RUNTIME_DEFAULTS } from "../../runtime/defaults.ts";
-import { renderCloudPromptTemplate } from "./templates.ts";
 
 export interface TerraformTemplateManifest {
   schemaVersion: 2;
@@ -19,7 +18,6 @@ export interface TerraformTemplateManifest {
   sourceDigest: string;
   contentDigest: string;
   metadataDigest?: string;
-  migratedFrom?: 1;
   failedApproaches: Array<{ approach: string; reason: string }>;
   artifacts: {
     terraform: boolean;
@@ -31,7 +29,7 @@ export interface TerraformTemplateManifest {
   };
 }
 
-export interface CloudDeploymentTemplate {
+export interface CloudTerraformTemplate {
   manifest: TerraformTemplateManifest;
   path: string;
   terraformPath: string;
@@ -41,14 +39,32 @@ export interface CloudDeploymentTemplate {
   verificationPath: string;
 }
 
-export function cloudDeploymentTemplateSource(template: CloudDeploymentTemplate): {
-  id: string; name: string; createdAt: string; updatedAt: string; kind: "terraform";
+export function cloudTerraformTemplateSource(template: CloudTerraformTemplate): {
+  id: string; name: string; createdAt: string; updatedAt: string;
 } {
-  return { id: template.manifest.id, name: template.manifest.name, createdAt: template.manifest.createdAt, updatedAt: template.manifest.updatedAt, kind: "terraform" };
+  return { id: template.manifest.id, name: template.manifest.name, createdAt: template.manifest.createdAt, updatedAt: template.manifest.updatedAt };
 }
 
 export function defaultCloudBundleDirectory(home = homedir()): string {
-  return userRuntimePaths(home).cloudDeploymentTemplates;
+  return userRuntimePaths(home).cloudTerraformTemplates;
+}
+
+function renderTerraformSummary(state: WorkflowState): string {
+  const details = state.details;
+  if (!details) return `# Terraform Deployment Summary\n\nProject root: ${state.root}\n`;
+  const lines: string[] = [
+    `# Terraform Deployment: ${details.vendor}`,
+    "",
+    `**Objective**: ${details.request}`,
+    `**Project Root**: ${state.root}`,
+  ];
+  if (details.successfulSteps.length > 0) {
+    lines.push("\n## Validated Steps", ...details.successfulSteps.map((s) => `- ${s.command} ${s.args.join(" ")} (${s.intent})`));
+  }
+  if (details.failedApproaches.length > 0) {
+    lines.push("\n## Avoided Failed Approaches", ...details.failedApproaches.map((f) => `- ⚠️ ${f.approach}: ${f.reason}`));
+  }
+  return lines.join("\n");
 }
 
 function excluded(name: string): boolean {
@@ -237,27 +253,27 @@ function digestBundleContent(path: string): string {
   return createHash("sha256").update(parts.join("\n")).digest("hex");
 }
 
-export function saveCloudDeploymentTemplate(
+export function saveCloudTerraformTemplate(
   requestedName: string,
   terraformSource: string,
   state: WorkflowState,
   directory = defaultCloudBundleDirectory(),
   savedAt = new Date(),
   artifactWorkspace?: string,
-): CloudDeploymentTemplate {
+): CloudTerraformTemplate {
   if (state.mode !== "cloud" || !state.details) throw new Error("Cloud workflow state is required");
   if (!isAbsolute(terraformSource) || !existsSync(terraformSource) || !statSync(terraformSource).isDirectory()) throw new Error("Terraform source directory is required");
   const name = requestedName.replace(/[\r\n]+/gu, " ").replace(/\s+/gu, " ").trim().slice(0, CLOUD_RUNTIME_DEFAULTS.templates.nameMaxLength);
-  if (!name) throw new Error("Cloud Deployment Template name is required");
+  if (!name) throw new Error("Terraform Template name is required");
   const temporary = `${directory}/.${process.pid}.${randomUUID()}.tmp`;
   const artifacts = writeBundleArtifacts(temporary, terraformSource, artifactWorkspace, state);
-  writeAtomic(join(temporary, "summary.md"), `${renderCloudPromptTemplate(state)}\n`);
+  writeAtomic(join(temporary, "summary.md"), `${renderTerraformSummary(state)}\n`);
   const sourceDigest = digestDirectory(join(temporary, "terraform"));
   const manifest = sealManifest(buildManifest(state, name, sourceDigest, savedAt.toISOString(), savedAt.toISOString(), artifacts, digestBundleContent(temporary)));
   const path = join(directory, manifest.id);
   if (existsSync(path)) {
     rmSync(temporary, { recursive: true, force: true });
-    throw new Error(`Cloud Deployment Template already exists: ${manifest.id}`);
+    throw new Error(`Terraform Template already exists: ${manifest.id}`);
   }
   try {
     writeAtomic(join(temporary, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
@@ -278,13 +294,13 @@ export function saveCloudDeploymentTemplate(
   };
 }
 
-export function updateCloudDeploymentTemplate(
-  template: CloudDeploymentTemplate,
+export function updateCloudTerraformTemplate(
+  template: CloudTerraformTemplate,
   terraformSource: string,
   state: WorkflowState,
   savedAt = new Date(),
   artifactWorkspace?: string,
-): CloudDeploymentTemplate {
+): CloudTerraformTemplate {
   if (state.mode !== "cloud" || !state.details) throw new Error("Cloud workflow state is required");
   if (!isAbsolute(terraformSource) || !existsSync(terraformSource) || !statSync(terraformSource).isDirectory()) throw new Error("Terraform source directory is required");
   const temporary = `${template.path}.${process.pid}.${randomUUID()}.tmp`;
@@ -292,7 +308,7 @@ export function updateCloudDeploymentTemplate(
   let manifest: TerraformTemplateManifest;
   try {
     const artifacts = writeBundleArtifacts(temporary, terraformSource, artifactWorkspace, state);
-    writeAtomic(join(temporary, "summary.md"), `${renderCloudPromptTemplate(state)}\n`);
+    writeAtomic(join(temporary, "summary.md"), `${renderTerraformSummary(state)}\n`);
     manifest = sealManifest({
       ...buildManifest(state, template.manifest.name, digestDirectory(join(temporary, "terraform")), template.manifest.createdAt, savedAt.toISOString(), artifacts, digestBundleContent(temporary)),
       id: template.manifest.id,
@@ -309,46 +325,63 @@ export function updateCloudDeploymentTemplate(
   return { manifest: manifest!, path: template.path, terraformPath: join(template.path, "terraform"), chartsPath: join(template.path, "charts"), discoveryPath: join(template.path, "discovery"), summaryPath: join(template.path, "summary.md"), verificationPath: join(template.path, "verification.md") };
 }
 
-export function parseCloudDeploymentTemplate(path: string): CloudDeploymentTemplate | undefined {
+export function parseCloudTerraformTemplate(path: string): CloudTerraformTemplate | undefined {
   const manifestPath = join(path, "manifest.json");
   if (!existsSync(manifestPath)) return undefined;
   const raw = JSON.parse(readFileSync(manifestPath, "utf8")) as Record<string, unknown>;
-  if (![1, 2].includes(raw.schemaVersion as number) || typeof raw.id !== "string" || typeof raw.name !== "string"
+  if (raw.schemaVersion !== 2 || typeof raw.id !== "string" || typeof raw.name !== "string"
     || typeof raw.vendor !== "string" || !isCloudVendorId(raw.vendor)
     || typeof raw.createdAt !== "string" || typeof raw.updatedAt !== "string"
     || typeof raw.sourceDigest !== "string" || !existsSync(join(path, "terraform"))) return undefined;
-  const oldArtifacts = (raw.artifacts && typeof raw.artifacts === "object" ? raw.artifacts : {}) as TerraformTemplateManifest["artifacts"];
-  let manifest = raw.schemaVersion === 2 ? raw as unknown as TerraformTemplateManifest : ({
-    ...raw,
-    schemaVersion: 2,
-    migratedFrom: 1,
-    contentDigest: digestBundleContent(path),
-    artifacts: { ...oldArtifacts, reports: [], excluded: [] },
-  } as unknown as TerraformTemplateManifest);
+  let manifest = raw as unknown as TerraformTemplateManifest;
   if (typeof manifest.contentDigest !== "string") return undefined;
   if (manifest.metadataDigest && manifest.metadataDigest !== digestManifestMetadata(manifest)) return undefined;
   if (!manifest.metadataDigest) manifest = sealManifest(manifest);
   return { manifest, path, terraformPath: join(path, "terraform"), chartsPath: join(path, "charts"), discoveryPath: join(path, "discovery"), summaryPath: join(path, "summary.md"), verificationPath: join(path, "verification.md") };
 }
 
-export function listCloudDeploymentTemplates(directory?: string, home = homedir()): CloudDeploymentTemplate[] {
-  const directories = directory
-    ? [directory]
-    : [...new Set([defaultCloudBundleDirectory(home), legacyUserCloudTemplatePaths(home).deployments])];
-  return directories
-    .filter(existsSync)
-    .flatMap((path) => readdirSync(path, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory())
-      .map((entry) => parseCloudDeploymentTemplate(join(path, entry.name))))
-    .filter((template): template is CloudDeploymentTemplate => Boolean(template))
+export function listCloudTerraformTemplates(directory?: string, home = homedir()): CloudTerraformTemplate[] {
+  const target = directory ?? defaultCloudBundleDirectory(home);
+  if (!existsSync(target)) return [];
+  return readdirSync(target, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => parseCloudTerraformTemplate(join(target, entry.name)))
+    .filter((template): template is CloudTerraformTemplate => Boolean(template))
     .sort((left, right) => right.manifest.updatedAt.localeCompare(left.manifest.updatedAt) || left.manifest.name.localeCompare(right.manifest.name));
 }
 
-export function materializeCloudDeploymentTemplate(template: CloudDeploymentTemplate, workspace: string): { terraformPath: string } {
+export function persistAppliedTerraformArtifact(
+  state: WorkflowState,
+  terraformSource: string,
+  artifactWorkspace?: string,
+  savedAt = new Date(),
+  directory = defaultCloudBundleDirectory(),
+): { action: "created" | "updated"; template: CloudTerraformTemplate } {
+  if (state.mode !== "cloud" || !state.details || state.details.terraformRun?.phase !== "applied") {
+    throw new Error("An applied Cloud Terraform run is required");
+  }
+  const source = state.details.sourceTemplate
+    ? listCloudTerraformTemplates(directory).find((template) => template.manifest.id === state.details?.sourceTemplate?.id)
+    : undefined;
+  if (source) {
+    return {
+      action: "updated",
+      template: updateCloudTerraformTemplate(source, terraformSource, state, savedAt, artifactWorkspace),
+    };
+  }
+  const project = state.root.split("/").filter(Boolean).pop() || "project";
+  const name = `${state.details.vendor}-${project}-${savedAt.toISOString().replace(/[:.]/gu, "-")}`;
+  return {
+    action: "created",
+    template: saveCloudTerraformTemplate(name, terraformSource, state, directory, savedAt, artifactWorkspace),
+  };
+}
+
+export function materializeCloudTerraformTemplate(template: CloudTerraformTemplate, workspace: string): { terraformPath: string } {
   if (!isAbsolute(workspace)) throw new Error("Cloud artifact workspace must be absolute");
   const actualDigest = digestBundleContent(template.path);
-  if (actualDigest !== template.manifest.contentDigest) throw new Error("Cloud Deployment Template content digest mismatch; reuse is blocked");
-  if (template.manifest.metadataDigest !== digestManifestMetadata(template.manifest)) throw new Error("Cloud Deployment Template metadata digest mismatch; reuse is blocked");
+  if (actualDigest !== template.manifest.contentDigest) throw new Error("Terraform Template content digest mismatch; reuse is blocked");
+  if (template.manifest.metadataDigest !== digestManifestMetadata(template.manifest)) throw new Error("Terraform Template metadata digest mismatch; reuse is blocked");
   for (const name of ["terraform", "charts", "discovery", "reports"]) {
     const source = join(template.path, name);
     if (!existsSync(source)) continue;

package/.pi/lib/workflows/cloud/workspace.ts

@@ -3,6 +3,7 @@ import { randomUUID } from "node:crypto";
 import { isAbsolute, join, relative, resolve } from "node:path";
 
 import { PROJECT_CLOUD_RUNS_RELATIVE, projectRuntimePaths } from "../../runtime/paths.ts";
+import { cloudDetails, type WorkflowState } from "../state.ts";
 
 export interface CloudRunWorkspace {
   runId: string;
@@ -35,3 +36,8 @@ export function isCloudRunWorkspace(root: string, path: string): boolean {
   return !isAbsolute(remainder) && !remainder.startsWith("..")
     && remainder.split(/[\\/]/u).slice(0, 3).join("/") === PROJECT_CLOUD_RUNS_RELATIVE;
 }
+
+export function cloudArtifactDirectory(state: WorkflowState): string {
+  const path = cloudDetails(state)?.artifactDirectory;
+  return path && isCloudRunWorkspace(state.root, path) ? path : state.root;
+}

package/.pi/lib/workflows/state.ts

@@ -43,7 +43,6 @@ export interface CloudTemplateSource {
   name: string;
   createdAt: string;
   updatedAt: string;
-  kind?: "prompt" | "terraform";
 }
 
 export interface CloudRunnerSummary {
@@ -110,23 +109,13 @@ export interface WorkflowState {
   reason?: string;
 }
 
-interface LegacyWorkflowState {
-  version: 1;
-  active: boolean;
-  mode?: WorkflowMode;
-  root?: string;
-  activatedAt?: string;
-  deactivatedAt?: string;
-}
-
 function isCloudTemplateSource(value: unknown): value is CloudTemplateSource {
   if (!value || typeof value !== "object") return false;
   const data = value as Record<string, unknown>;
   return typeof data.id === "string"
     && typeof data.name === "string"
     && typeof data.createdAt === "string"
-    && typeof data.updatedAt === "string"
-    && (data.kind === undefined || data.kind === "prompt" || data.kind === "terraform");
+    && typeof data.updatedAt === "string";
 }
 
 function isCloudRunnerSummary(value: unknown): value is CloudRunnerSummary {
@@ -205,20 +194,7 @@ export function decodeWorkflowState(value: unknown): WorkflowState | undefined {
     }
     return data as unknown as WorkflowState;
   }
-
-  const legacy = data as unknown as LegacyWorkflowState;
-  if (legacy.version !== 1 || !legacy.active || !legacy.mode || !legacy.root || !legacy.activatedAt) {
-    return undefined;
-  }
-  return {
-    version: 2,
-    status: "active",
-    mode: legacy.mode,
-    root: legacy.root,
-    phase: "legacy",
-    activatedAt: legacy.activatedAt,
-    updatedAt: legacy.activatedAt,
-  };
+  return undefined;
 }
 
 export const WORKFLOW_STATE_CODEC: StateCodec<WorkflowState> = {
@@ -235,6 +211,10 @@ export function activeWorkflow(entries: readonly CustomSessionEntry[]): Workflow
   return state?.status === "active" ? state : undefined;
 }
 
+export function cloudDetails(state: WorkflowState): CloudWorkflowDetails | undefined {
+  return state.mode === "cloud" ? state.details : undefined;
+}
+
 export function createWorkflowState(
   mode: "vibe" | "sdd",
   root: string,

package/.pi/skills/hwcode-cloud/SKILL.md

@@ -27,7 +27,7 @@ The command already collected the provider, deployment choice, objective, and va
 
 The activation context includes a task artifact workspace inside the locked project root. Keep all generated Cloud-task artifacts there; never write them to the project root or invent top-level task directories.
 
-The run workspace is retained after the session so `/hwcode-cloud-save-template` can safely extract its validated artifacts. Do not move or duplicate these files into another temporary directory.
+The run workspace is retained after the session so a successful managed apply can automatically extract a validated local artifact bundle. Do not move or duplicate these files into another temporary directory.
 
 - `discovery/`: provider CLI skeletons, read-only snapshots, and API input exploration;
 - `terraform/`: Terraform source, module lock files, and generated provider configuration (never state files or tfvars with secrets);
@@ -130,4 +130,4 @@ On success, summarize:
 - ongoing cost, security, monitoring, backup, and credential-rotation considerations;
 - rollback and teardown procedure (do not execute teardown unless separately requested and approved).
 
-When saving a successful Terraform run, the local Deployment Template is a schema-v2 bundle. It contains filtered Terraform/Helm/discovery artifacts, verification guidance, an exclusion report, and a digest of the actual saved content. Runtime state, plans, tfvars, credentials, and discovered runtime identifiers must not be copied. Reuse is blocked if the bundle content no longer matches its manifest digest; schema-v1 bundles are migrated in memory when read.
+After a successful managed apply, HWCode automatically creates or updates a local schema-v2 Terraform artifact bundle. It contains filtered Terraform/Helm/discovery artifacts, verification guidance, an exclusion report, and a digest of the actual saved content. Runtime state, plans, tfvars, credentials, and discovered runtime identifiers must not be copied. Reuse is blocked if the bundle content no longer matches its manifest digest.

package/README.md

@@ -153,33 +153,34 @@ scanned through a verified ProxyJump. Runner execution requires Terraform,
 Terraform backend. The exact policy-checked file manifest is uploaded and its
 per-file digest is verified remotely before execution.
 
-After at least one cloud command succeeds, run
-`/hwcode-cloud-save-template [name]` to save the objective, validated execution
-sequence, failed approaches, prerequisites, and optional lessons learned as a
-local Prompt Template. A successful managed Terraform apply instead produces a
-schema-v2 Deployment Template bundle containing filtered Terraform, Helm,
-discovery and report artifacts plus verification notes, exclusion reasons, and
-content/metadata integrity digests. Each template records its user-facing name plus creation
-and update timestamps. Its prompt is layered into stable intent, prerequisites,
-the preferred known-good path, expensive failed paths that must not be retried,
-and the guarded execution contract. Prompt Templates are stored under
-`~/.hwcode/cloud/templates/prompts/`; Deployment Template bundles are stored
-under `~/.hwcode/cloud/templates/deployments/`, both with user-only permissions.
-Existing resources under the legacy `~/.hwcode/cloud/prompts/` and
-`~/.hwcode/cloud/templates/` locations remain discoverable and are updated in
-place when reused. Credential values are
-excluded and redacted before steps are persisted.
-
-Use `/hwcode-cloud-template [additional instructions]` to select and start a
-saved template by name and last-updated time. `/hwcode-cloud` also offers saved
-templates when it starts without an inline request. If a session started from a
-template, saving again asks whether to update that source template or create a
-new one. The files use a Pi-compatible
-Markdown/frontmatter format, but HWCode intentionally keeps them out of Pi
-resource discovery so each saved template does not become another slash
-command. Templates are extension-private resources and always run through the
-fixed `/hwcode-cloud-template` entry point, preserving credential isolation and
-Cloud approval guards.
+Knowledge capture is independent from workflow completion. A background Worker
+checks settled conversations once per minute and asks the active model to
+review only the session delta since the last successful checkpoint. It runs for
+ordinary conversations and Vibe, SDD, and Cloud alike, produces no visible
+assistant turn, and is cancelled when new input or a new agent run starts.
+
+Reusable knowledge is stored under `~/.hwcode/knowledge/` using two tracks.
+Short, high-confidence rules live under `rules/` and every applicable rule file
+is loaded when a session starts. Detailed SOPs and evolving engineering
+experience live under `topics/`; only the bounded `MEMORY.md` keyword index is
+loaded into the prompt, while `catalog.json` remains a complete token-free
+machine index. The `hwcode_knowledge_lookup` tool loads a detailed topic on
+demand. Exact repeats are reinforced, safe explicit revisions replace their
+source, and ambiguous conflicts are quarantined under `pending/`. Legacy
+`index.json` and `records/` data are neither loaded nor migrated.
+
+A successful managed Terraform apply additionally produces a schema-v2
+Terraform Template bundle containing filtered Terraform, Helm, discovery and
+report artifacts plus verification notes, exclusion reasons, and
+content/metadata integrity digests. Bundles are stored under
+`~/.hwcode/cloud/templates/terraform/` with user-only permissions; credential
+values are excluded and redacted before artifacts are persisted. A successful
+managed apply automatically creates a new bundle, or atomically updates the
+source bundle when the run started from one. `/hwcode-cloud` offers saved
+bundles when it starts without an inline request. Bundles remain
+extension-private executable artifacts, separate from the knowledge base, and
+reuse always goes through the normal Cloud credential isolation and approval
+guards.
 
 ## Internal architecture
 
@@ -197,10 +198,11 @@ Reusable behavior lives under `.pi/lib/`:
 
 Runtime data is separated by ownership: project SDD specifications live under
 `.hwcode/specs/`, retained Cloud run artifacts live under
-`.hwcode/cloud/runs/<run-id>/`, and user-private credentials, SSH trust, and
-templates live under `~/.hwcode/cloud/`. Cloud run artifacts are deliberately
-retained for inspection and later template extraction; HWCode does not apply a
-time-based cleanup policy.
+`.hwcode/cloud/runs/<run-id>/`, user-private credentials, SSH trust, and
+Terraform Templates live under `~/.hwcode/cloud/`, and the cross-workflow
+knowledge base lives under `~/.hwcode/knowledge/`. Cloud run artifacts are
+deliberately retained for inspection and automatic bundle extraction; HWCode
+does not apply a time-based cleanup policy.
 
 `settings.json` is layered as defaults → profile → project for settings such as
 context and hidden commands. `welcome.json` uses a single replacing resource.

package/bin/hwcode.js

@@ -56,9 +56,7 @@ HWCode 交互命令:
   /hwcode-vibe [需求]            启动持续对话式 Vibe Coding workflow
   /hwcode-sdd [需求]             启动测试优先的 Spec-Driven workflow
   /hwcode-cloud [需求]           启动凭据隔离、变更审批的云部署 workflow
-  /hwcode-cloud-template [补充]  从本地成功模板启动 Cloud workflow
-  /hwcode-cloud-save-template    保存或更新 Prompt/Terraform Deployment Template
-  /hwcode                        查看、完成或取消当前 workflow
+  /hwcode-status                 查看、完成或取消当前 workflow
   /cd <目录>                     持久切换当前会话工作目录
   /model                         选择模型
   /login                         登录或配置模型提供商
@@ -115,6 +113,7 @@ for (const extension of [
 	"cwd.ts",
 	"footer-tps.ts",
 	"hwcode.ts",
+	"knowledge.ts",
 	"model-providers.ts",
 	"welcome.ts",
 	"workflows.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hadooppei/hwcode",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "A customizable terminal coding agent with local-model support and HWCode workflows.",
   "type": "module",
   "bin": {