agentlas 1.0.14 → 1.0.16

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 1.0.16 — 2026-07-30
+
+- **Project-scoped plugin listing now fails closed.** A missing, unsafe, or
+  uninitialized `--project` path returns a clear error instead of silently
+  showing the global Hub catalog as if project compatibility had been checked.
+- Plugin listing names its actual scope: the global Hub catalog does not claim
+  to evaluate project compatibility or local installation state.
+- Unknown, conflicting, or incomplete plugin flags now return usage errors
+  instead of being ignored.
+
+## 1.0.15 — 2026-07-29
+
+- **Agent Cloud saves work from a new machine or fresh clone.** Before writing,
+  the terminal resolves the signed-in owner's exact asset revision by
+  `slug` and scope, then keeps the conditional-write guard on that revision.
+  A missing local receipt no longer turns an owned asset into a false create
+  conflict.
+- **A real stale-copy conflict stays fail-closed.** The terminal stops before
+  replacing a newer server revision, reports its identity, and offers an
+  explicit `--overwrite` only when the owner deliberately chooses the current
+  folder over the newer copy.
+- Conflict messages now describe ownership and the next command instead of
+  exposing storage precondition terminology.
+
 ## 1.0.14 — 2026-07-29
 
 - **Write-capable commands now prepare every project automatically.** The first

package/engine/agentlas-cloud-runtime.cjs

@@ -74,7 +74,7 @@ function buildManifest(root, options = {}) {
     memoryPolicy: { writeBack: "ask", publicCopy: "reset" },
     memory: files.filter((file) => [".agentlas/memory-map.json", ".agentlas/agent-card.json"].includes(file.path)).map((file) => file.path),
     allowRead: ["README.md", "AGENTS.md", "agent.md", "skills/**", ".agentlas/*.json"],
-    denyRead: [".env", ".env.*", "**/secrets/**", "**/credentials/**", "**/cookies/**", "**/*token*", "**/*secret*"],
+    denyRead: [".env", ".env.*", "secrets/**", "**/secrets/**", "credentials/**", "**/credentials/**", "cookies/**", "**/cookies/**"],
     publicExportPolicy: "clean-copy",
     requiredRuntime: ["mcp-client"],
     license: "call-only-default",
@@ -92,7 +92,13 @@ function scanFiles(files) {
     findings.push({ verdict, type, path: file.path, ...(line ? { line } : {}), message, redacted: true });
   }
   for (const file of files) {
-    if ([".env", ".env.local"].includes(file.path) || /(?:^|\/)(secrets|credentials|cookies)\//i.test(file.path) || /token|secret/i.test(file.path)) {
+    // A credential store is a path SEGMENT, never a filename substring. The old
+    // `/token|secret/i` test blocked ordinary vocabulary — measured 2026-07-29,
+    // it gave the live `web-master` package a BLOCK verdict for its own design
+    // system (`token-architecture.md`, `reference-token-db.json`). Dropping it
+    // costs no coverage: the per-line SECRET_PATTERNS scan below reads every
+    // packaged file and is the check that actually looks at values.
+    if (/^\.env(\.|$)/.test(file.path.split("/").pop() || "") || /(?:^|\/)(secrets|credentials|cookies)\//i.test(file.path)) {
       add("BLOCK", "credential-path", file, null, "Credential-like file path is excluded from Cloud package and public publish.");
     }
     file.content.split(/\r?\n/).forEach((line, index) => {

package/engine/agentlas-workforce.cjs

@@ -142,13 +142,14 @@ const HUB_SECRET_PATTERNS = [
   ["credential_assignment", /\b(?:api[_-]?key|access[_-]?key|client[_-]?secret|secret|token|password|passwd|cookie)\s*[:=]\s*['"]?[^\s'";,]{8,}/i],
   ["credential_url", /\b[A-Za-z][A-Za-z0-9+.-]*:\/\/[^\s/:@]+:[^\s/@]+@[^\s/]+/i],
 ];
-const WORKFORCE_ONTOLOGY_MENU = [
-  "Controlled communities: community:software-engineering, community:backend-engineering, community:frontend-engineering, community:database-engineering, community:payments-engineering, community:quality-engineering, community:security-engineering, community:data-engineering, community:ai-engineering, community:devops, community:product-design, community:research, community:marketing, community:finance, community:corporate-development, community:insurance, community:insurance-actuarial, community:insurance-claims, community:insurance-underwriting, community:human-resources, community:information-technology, community:legal, community:travel, community:operations, community:agent-systems.",
-  "Controlled roles: role:software-architect, role:backend-engineer, role:frontend-engineer, role:database-engineer, role:payments-engineer, role:quality-engineer, role:security-engineer, role:ontology-architect, role:agent-runtime-engineer, role:researcher, role:ma-diligence-lead, role:insurance-actuary, role:claims-diligence-specialist, role:underwriting-diligence-specialist, role:travel-planner.",
-  "Canonical skills: skill:software-architecture, skill:api-design, skill:server-implementation, skill:frontend-implementation, skill:data-modeling, skill:database-querying, skill:billing-integration, skill:transaction-integrity, skill:test-design, skill:verification, skill:security-review, skill:ontology-modeling, skill:knowledge-graph-design, skill:multi-agent-orchestration, skill:runtime-integration, skill:evidence-synthesis, skill:deal-diligence, skill:valuation, skill:actuarial-reserving, skill:solvency-analysis, skill:claims-liability-assessment, skill:underwriting-portfolio-analysis, skill:travel-planning.",
-  "Canonical tool capabilities: tool:file-system, tool:file-read, tool:file-write, tool:shell, tool:web-search, tool:browser, tool:mongodb, tool:database, tool:github, tool:payments.",
-  "Use artifact:<kind> for consumes, produces and edge artifactKinds. consumes and produces are hard candidate-profile declaration gates: list an artifact there only when the Hub package itself must declare that exact input/output capability. Put ordinary workflow inputs, outputs, and handoffs in the slot task and edges.artifactKinds instead. Default requiredRoles to an empty array. There is no optionalRoles field: express desired role fit through title, task, optionalCommunities, and optionalSkills. Require an exact controlled role only when a candidate lacking that exact declared role could not execute the assignment; never invent a near-synonym role ID.",
-  "Treat required roles, skills, tools, artifacts and authorities as non-negotiable hard constraints only when Hub package declarations must prove them. Legacy Hub profiles can legitimately have empty role/tool fields. Use a broad required community for the job-family boundary, put desired expertise in optional communities/skills plus the role task, and let the host LLM judge title, summary and semantic evidence.",
+const WORKFORCE_ONTOLOGY_GUIDE = [
+  "Roles, communities, skills and knowledge are open-world English semantic IDs. Seed values are aliases and graph anchors, never allowlists. Author a new faithful namespaced ID when no seed expresses the work.",
+  "Community seed examples: community:software-engineering, community:backend-engineering, community:frontend-engineering, community:database-engineering, community:payments-engineering, community:quality-engineering, community:security-engineering, community:data-engineering, community:ai-engineering, community:devops, community:product-design, community:research, community:marketing, community:finance, community:legal, community:travel, community:operations, community:agent-systems.",
+  "Role seed examples: role:software-architect, role:backend-engineer, role:frontend-engineer, role:database-engineer, role:payments-engineer, role:quality-engineer, role:security-engineer, role:ontology-architect, role:agent-runtime-engineer, role:researcher, role:travel-planner.",
+  "Skill seed examples: skill:software-architecture, skill:api-design, skill:server-implementation, skill:frontend-implementation, skill:data-modeling, skill:test-design, skill:verification, skill:ontology-modeling, skill:knowledge-graph-design, skill:evidence-synthesis, skill:travel-planning.",
+  "Tool capability seed examples: tool:file-system, tool:file-read, tool:file-write, tool:shell, tool:web-search, tool:browser, tool:mongodb, tool:database, tool:github, tool:payments. Tool binding remains a prepare-time runtime concern.",
+  "Use artifact:<kind> only for edges.artifactKinds. Do not fill consumes, produces, requiredRoles, requiredToolCapabilities, requiredAuthorities, forbiddenAuthorities, or modalities on a slot — tools, authorities, and modalities attach to the executing runtime, not the agent card, and card-declaration gates on those fields only exclude real candidates. Put ordinary workflow inputs, outputs, and handoffs in the slot task and edges.artifactKinds. Express desired role fit through title, task, optionalCommunities, and optionalSkills.",
+  "Use a broad required community for the job-family boundary, put desired expertise in optional communities/skills plus the role task, and let the host LLM judge title, summary and semantic evidence.",
   "forbiddenCommunities and excludedCommunities are not exhaustive lists of every unused job family. Add only an explicit user prohibition or an inherent incompatibility with the assignment. Never forbid a broad ancestor, descendant, adjacent, or legitimately co-occurring community merely because another community was selected.",
 ].join("\n");
 
@@ -1013,6 +1014,23 @@ function validateWorkOrder(value) {
   }
   const slots = assertArray(order.roleSlots, "workOrder.roleSlots", MAX_SLOTS, { min: 1 });
   const seen = new Set();
+  // An absent list-valued slot field IS the empty constraint (2026-07-30):
+  // normalize (absent -> []) BEFORE validation and before the order is
+  // digested or sent, so a lean-form author and a full-form author produce
+  // byte-identical canonical orders. Full forms pass through untouched.
+  const SLOT_LIST_FIELDS = [
+    "requiredCommunities", "optionalCommunities", "excludedCommunities",
+    "requiredRoles", "requiredSkills", "optionalSkills", "requiredKnowledge",
+    "requiredToolCapabilities", "consumes", "produces", "requiredAuthorities",
+    "forbiddenAuthorities", "runtimes", "languages", "modalities",
+  ];
+  for (let index = 0; index < slots.length; index += 1) {
+    if (slots[index] && typeof slots[index] === "object" && !Array.isArray(slots[index])) {
+      for (const field of SLOT_LIST_FIELDS) {
+        if (!Object.prototype.hasOwnProperty.call(slots[index], field)) slots[index][field] = [];
+      }
+    }
+  }
   for (let index = 0; index < slots.length; index += 1) {
     const slot = assertObject(slots[index], `roleSlots[${index}]`);
     assertExactKeys(slot, [
@@ -1850,14 +1868,14 @@ function buildPrompts(task, identity) {
     "Return the direct agentlas.workforce-work-order.v1 JSON object. Do not emit schemaVersion=agentlas.workforce-leader-call.v1 and do not emit toolCall, name, or arguments wrappers. The host invokes workforce.search_candidates with your exact validated WorkOrder.",
     "The direct WorkOrder top level must contain exactly: schemaVersion, workOrderId, taskBrief, redacted, ontologyVersion, roleSlots, edges, forbiddenCommunities, selectionPolicy.",
     `Exact direct WorkOrder example: ${stableJson(workOrderShape)}`,
-    "Every roleSlots item must contain exactly slotId, title, task, cardinality, criticality, requiredCommunities, optionalCommunities, excludedCommunities, requiredRoles, requiredSkills, optionalSkills, requiredKnowledge, requiredToolCapabilities, consumes, produces, requiredAuthorities, forbiddenAuthorities, runtimes, languages, modalities, and allowedEntityKinds; minimumEvidenceLevel is the only optional extra key. Empty arrays must still be present; the host will not add them.",
-    "consumes and produces are hard eligibility fields matched against exact candidate-profile declarations. Do not use them for ordinary project workflow. Describe normal inputs/outputs in task and represent inter-slot handoffs with edges and edges.artifactKinds.",
+    "Every roleSlots item must contain slotId, title, task, cardinality, criticality, and allowedEntityKinds; minimumEvidenceLevel is optional. Constrain the hire only through requiredCommunities, optionalCommunities, excludedCommunities, requiredSkills, optionalSkills, requiredKnowledge, runtimes, and languages, and only when the constraint is genuine. Any list field you leave out is the empty constraint — the host normalizes absent to [] before validation and digest, so omit empty ones instead of spelling [].",
+    "Never fill requiredToolCapabilities, requiredAuthorities, forbiddenAuthorities, consumes, produces, requiredRoles, or modalities: tools, authorities, and modalities attach to the executing runtime, not the agent card, and those gates only exclude real candidates. Describe normal inputs/outputs in task and represent inter-slot handoffs with edges and edges.artifactKinds.",
     "workOrderId and every concept/reference id must match [A-Za-z0-9][A-Za-z0-9._:/@-]{1,255} and have total length at most 255 characters. taskBrief is limited to 64000 characters; each slot title to 160 and slot task to 32000 — describe each responsibility as fully as the work honestly needs. Each id array is limited to 256 unique items.",
     "roleSlots must contain 1-32 items. cardinality must be an integer from 1 through 16. criticality must be exactly required or optional. allowedEntityKinds must be a non-empty unique subset of executable agent, team. group is ontology/discovery metadata and cannot be executed. minimumEvidenceLevel, when authored, must be exactly declared, checked, demonstrated, or attested.",
     "edges must contain at most 128 items. Every edge must contain exactly from, to, relation, and artifactKinds. from and to must reference declared slotId values. relation must be exactly one of reportsTo, handsOffTo, reviews, coordinatesWith.",
     "forbiddenCommunities and edges must be explicitly authored arrays. selectionPolicy must contain exactly allowHistoryEvidence=false, integer minimumCandidatesPerSlot from 2 through 30, and integer maximumCandidatesPerSlot from 2 through 100 that is not below the minimum.",
     "A community cannot appear in forbiddenCommunities or a slot's excludedCommunities when that same slot requires or optionally prefers it. Also avoid broader ancestor, descendant, adjacent, and legitimately co-occurring exclusions; the host rejects exact contradictions but does not invent ontology lineage or mutate your decision.",
-    `redacted must be true and ontologyVersion must be exactly ${WORKFORCE_ONTOLOGY_VERSION}. Do not invent controlled concept IDs.`,
+    `redacted must be true and ontologyVersion must be exactly ${WORKFORCE_ONTOLOGY_VERSION}; this pins graph semantics, not a finite vocabulary. Write all discovery-facing content in English and use faithful open namespaced concept IDs.`,
   ].join("\n");
   const selectionSchemaRequirements = [
     "Return the direct agentlas.workforce-selection.v1 JSON object. Do not emit schemaVersion=agentlas.workforce-leader-call.v1 and do not emit toolCall, name, or arguments wrappers. The host invokes workforce.validate_selection with your exact validated Selection.",
@@ -1887,15 +1905,14 @@ function buildPrompts(task, identity) {
       "Any specialized domain explicitly present in the task with distinct failure or accountability semantics must have its own accountable domain slot. Examples include payments, insurance, legal, finance, travel, and regulated science or operations. Never collapse such a named domain into generic backend, software, database, or implementation work. This is a general job-analysis rule, not a fixed list of required professions.",
       "forbiddenCommunities is not the inverse of selected communities and not an exhaustive list of unused professions. Add a global or slot exclusion only when the user explicitly prohibited that community or when participation is inherently incompatible with the assignment. Empty exclusion arrays are correct when no such negative constraint exists.",
       "Never forbid or exclude a broad ancestor, descendant, adjacent, or legitimately co-occurring community merely because a narrower job family was selected. Check every exclusion against all requiredCommunities and optionalCommunities before returning JSON.",
-      "Hard requirements mean absence makes the assignment impossible and the Hub catalog must prove eligibility; importance alone is not a hard gate. Prefer a broad required community plus optional skills when legacy declarations may be sparse. requiredRoles must default to []; there is no optionalRoles field, so express desired role fit through title, task, optionalCommunities, and optionalSkills unless the exact role declaration is truly execution-impossible to omit.",
-      "A requiredToolCapabilities entry means the selected worker itself must invoke that exact host tool. Designing a database, writing tests, or discussing a tool does not by itself require tool:database, tool:shell, or any other tool declaration.",
-      "consumes and produces require the selected Hub candidate profile itself to declare those exact artifacts. Ordinary workflow dependencies and handoffs belong in task and edges, not these hard fields.",
+      "Hard requirements mean absence makes the assignment impossible and the Hub catalog must prove eligibility; importance alone is not a hard gate. Prefer a broad required community plus optional skills when legacy declarations may be sparse. Do not author requiredRoles; express desired role fit through title, task, optionalCommunities, and optionalSkills.",
+      "Do not author requiredToolCapabilities, requiredAuthorities, forbiddenAuthorities, consumes, produces, or modalities: tools, authorities, and modalities attach to the executing runtime, not the agent card, and card-declaration gates on those fields only exclude real candidates. Ordinary workflow dependencies and handoffs belong in task and edges.",
       "Before returning JSON, self-check that every explicitly named specialized domain responsibility is independently represented, every primary domain responsibility has an accountable slot, every exclusion is explicit or inherently incompatible and does not conflict with job-family lineage, requiredRoles is empty unless strictly indispensable, and every other hard field passes the execution-impossible test.",
       "Return exactly one direct WorkOrder JSON object. Do not choose agents yet. Do not use ratings, popularity, invocation history, or revenue.",
-      "You must explicitly author every required schema field. The host will never fill or default a missing hard field.",
+      "Explicitly author every structural field (slotId, title, task, cardinality, criticality, allowedEntityKinds, edges, forbiddenCommunities, selectionPolicy). A list-valued slot field you leave out is the empty constraint; the host normalizes absent to [].",
       "Never copy secrets, local file contents, account identifiers, or private memory into taskBrief; summarize them as local protected inputs and set redacted=true.",
       `ontologyVersion must be exactly ${WORKFORCE_ONTOLOGY_VERSION}.`,
-      WORKFORCE_ONTOLOGY_MENU,
+      WORKFORCE_ONTOLOGY_GUIDE,
       searchSchemaRequirements,
     ].join("\n"),
     searchUser: task,
@@ -1906,12 +1923,12 @@ function buildPrompts(task, identity) {
       "Return a complete replacement WorkOrder authored by you. Preserve workOrderId and the redacted taskBrief exactly. Preserve every genuinely essential responsibility; add or separate an omitted accountable domain job family when the task requires it.",
       "Any specialized domain explicitly present in the task with distinct failure or accountability semantics must remain or become its own accountable domain slot. Examples include payments, insurance, legal, finance, travel, and regulated science or operations. Never collapse one into generic backend, software, database, or implementation work.",
       "Reconsider only hard eligibility gates exposed by the gap codes. gap:excluded:missing-required-skill means reassess requiredSkills and move desired expertise to optionalSkills/task unless exact profile proof is execution-essential. gap:excluded:missing-required-tool means remove or revise requiredToolCapabilities unless the worker itself must invoke that exact host tool. gap:excluded:missing-consumed-artifact and gap:excluded:missing-produced-artifact mean move normal workflow inputs/outputs to task or edges unless the candidate profile itself must declare that exact artifact. gap:excluded:entity-kind-mismatch means reconsider allowedEntityKinds and permit executable agent or team when it can own the accountability; never select group. gap:selection-requested-content-expansion means revisit the responsibility and semantic job-family description without reading candidate identities or content.",
-      "requiredRoles must default to []; because optionalRoles does not exist, move desired role fit to title, task, optionalCommunities, or optionalSkills unless absence of the exact declared role truly makes execution impossible. A required tool means the worker must invoke that exact host tool, not merely reason about the underlying system. consumes and produces are exact candidate-profile declaration gates; ordinary handoffs belong in task and edges.",
+      "Do not author requiredRoles, requiredToolCapabilities, requiredAuthorities, forbiddenAuthorities, consumes, produces, or modalities; move desired fit to title, task, optionalCommunities, or optionalSkills — ordinary handoffs belong in task and edges.",
       "Preserve community prohibitions explicitly stated in the redacted taskBrief. You may correct exclusions inferred by the prior job analysis when they conflict with required/optional job-family lineage or when coverage gap codes show forbidden-community exclusion. Never turn forbiddenCommunities or excludedCommunities into an exhaustive list of unused families, and never forbid a broad, adjacent, or legitimately co-occurring community merely to sharpen a slot.",
       "Before returning JSON, self-check that each explicitly named specialized domain responsibility has an independent accountable slot and that every hard gate still satisfies the execution-impossible or exact-profile-declaration test.",
       "The host will validate your replacement exactly and will not add slots, defaults, constraints, candidates, or substitutions. At most two total semantic WorkOrder refinements are allowed.",
       `ontologyVersion must remain exactly ${WORKFORCE_ONTOLOGY_VERSION}.`,
-      WORKFORCE_ONTOLOGY_MENU,
+      WORKFORCE_ONTOLOGY_GUIDE,
       searchSchemaRequirements,
     ].join("\n"),
     selectionSystem: [

package/engine/cloud-assets/cas.cjs

@@ -42,9 +42,14 @@ function cloudCasResponseError(response, label) {
   let message = `${label} failed with HTTP ${response.status}`;
   if (response.status === 412 && code === "cloud_agent_revision_conflict") {
     const current = body && body.current ? body.current : body && body.conflict && body.conflict.current;
+    // 서버가 알려준 사실만 사람 말로 전달한다. 내부 개념(precondition, base, 연결)은
+    // 사용자에게 아무 의미가 없다 — 기준은 "이 이름이 내 계정 것인가" 하나다.
     message = current
-      ? `다른 PC에서 이 Agent Cloud 자산이 변경되었습니다. 자동 덮어쓰기는 중단했습니다. \`agentlas cloud list\`로 최신 revision을 확인하고 \`agentlas cloud restore ${current.slug || "<slug>"}\`로 복원한 뒤 변경 사항을 병합하세요.`
-      : "이 Agent Cloud 자산은 다른 PC에서 삭제되었거나 다른 식별자로 다시 생성되었습니다. 자동 재생성은 중단했습니다. `agentlas cloud list`로 현재 상태를 확인하세요.";
+      ? `업로드하지 않았습니다. "${current.slug || "이 이름"}"의 서버 버전이 지금 보낸 것과 맞지 않습니다` +
+        `${current.updatedAt ? ` (서버 쪽 마지막 저장: ${current.updatedAt})` : ""}.\n` +
+        `  내 계정 자산이면: agentlas cloud restore ${current.slug || "<slug>"} 로 받아서 확인한 뒤 다시 저장하세요.\n` +
+        `  (서버 cloudId ${current.cloudId || "?"} · revision ${current.revision || "?"})`
+      : "업로드하지 않았습니다. 이 이름의 자산이 삭제됐거나 다른 계정 소유입니다. `agentlas cloud list`로 내 자산을 확인하세요.";
   } else if (response.status === 428 && code === "client_upgrade_required") {
     message = "No base revision is available to safely update the existing Cloud asset. The server revision will not be copied automatically. Check `agentlas cloud list`, restore with `agentlas cloud restore <slug>`, then save again.";
   } else if (response.status === 503 && code === "cloud_mutations_maintenance") {

package/engine/cloud-assets/commands.cjs

@@ -10,12 +10,161 @@
  *    명시적 --visibility marketplace 로만 publish가 된다.
  * 오류는 throw → 명령 파일이 ctx.err + return 1 로 처리한다 (process.exit 금지).
  */
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const readline = require("node:readline/promises");
 const cloudRuntime = require("../agentlas-cloud-runtime.cjs");
 const { installHubAgent } = require("../hub/install.cjs");
 const { callHubTool, HubError } = require("../cloud/hub-client.cjs");
 const { packageCloudAgent } = require("./package.cjs");
 const { deleteCloudAgent } = require("./cas.cjs");
 const { listOwnedCloudAgents, restoreOwnedCloudAgent } = require("./restore.cjs");
+const workforceDeps = require("../workforce/deps.cjs");
+const workforceCapture = require("../workforce/capture.cjs");
+
+const PURPOSE_QUESTION = "What concrete work should this agent complete, and what should the finished result look like?";
+
+function purposeRepairNeeded(result) {
+  const ids = new Set((result?.review?.findings || []).map((finding) => finding.id));
+  return ids.has("routing-card-required") ||
+    (result?.review?.findings || []).some((finding) =>
+      finding.id === "routing-card-invalid" && /summary|capabilities|name|id|workforce/i.test(finding.message || ""));
+}
+
+async function askPurpose(ctx, flags) {
+  if (typeof flags.purpose === "string" && flags.purpose.trim()) return flags.purpose.trim();
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return "";
+  const prompt = ctx.lang === "ko"
+    ? "이 에이전트가 실제로 끝내야 할 일과, 완료됐을 때 나와야 할 결과를 평소 말하듯 적어주세요: "
+    : `${PURPOSE_QUESTION} `;
+  const terminal = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return String(await terminal.question(prompt)).trim();
+  } finally {
+    terminal.close();
+  }
+}
+
+function parsePurposeProjection(raw) {
+  const text = String(raw || "").trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
+  const value = JSON.parse(text);
+  const ids = (input, prefix, min = 1) => {
+    if (!Array.isArray(input)) throw new Error(`${prefix} must be an array`);
+    const pattern = prefix === "capability"
+      ? /^[a-z][a-z0-9]*(_[a-z0-9]+)+$/
+      : new RegExp(`^${prefix}:[a-z0-9][a-z0-9-]*$`);
+    const output = [...new Set(input.map((item) => String(item).trim()).filter((item) => pattern.test(item)))];
+    if (output.length < min) throw new Error(`${prefix} is incomplete`);
+    return output;
+  };
+  const requiredText = (key) => {
+    const output = typeof value[key] === "string" ? value[key].trim() : "";
+    if (!output) throw new Error(`${key} is missing`);
+    return output;
+  };
+  return {
+    titleEn: requiredText("titleEn"),
+    titleKo: requiredText("titleKo"),
+    summary: requiredText("summary"),
+    descriptionKo: requiredText("descriptionKo"),
+    capabilities: ids(value.capabilities, "capability", 2),
+    roles: ids(value.roles, "role"),
+    communities: ids(value.communities, "community"),
+    skills: ids(value.skills, "skill", 2),
+    knowledge: ids(value.knowledge, "knowledge"),
+  };
+}
+
+async function projectPurposeWithConnectedModel(ctx, answer, fallbackName) {
+  const runtime = workforceDeps.resolveWorkforceRuntime(ctx.db()).roleRuntimes.orchestrator;
+  const system = [
+    "Convert an ordinary-language agent purpose into one English internal routing resume.",
+    "The answer may be in any language. Preserve meaning; do not add tools, runtimes, languages, modalities, permissions, authorities, or forbidden authorities.",
+    "Return JSON only.",
+  ].join(" ");
+  const prompt = [
+    `Working name: ${fallbackName}`,
+    `User explanation: ${answer}`,
+    "",
+    'Return {"titleEn":"","titleKo":"","summary":"","descriptionKo":"","capabilities":[],"roles":[],"communities":[],"skills":[],"knowledge":[]}.',
+    "summary must be a concrete English description of work and finished result.",
+    "capabilities are 2-8 English snake_case verb-object phrases.",
+    "roles, communities, skills, knowledge are faithful open-world English IDs with role:, community:, skill:, knowledge: prefixes.",
+    "titleKo and descriptionKo are display translations only; every routing field remains English.",
+  ].join("\n");
+  let raw;
+  if (runtime.mode === "api") {
+    raw = await workforceCapture.runApi(runtime.backend, runtime.model, system, prompt, {});
+  } else {
+    if (runtime.kind === "gemini") {
+      throw new Error("The connected Gemini CLI cannot run this no-tool repair safely yet. Choose Codex/Claude or a BYOK model and retry.");
+    }
+    const env = await workforceCapture.buildChildEnv(ctx.db(), { cwd: process.cwd(), projectPath: process.cwd() });
+    raw = await workforceCapture.captureRuntime(runtime.kind, system, prompt, {
+      cwd: workforceCapture.runCwd(),
+      env,
+      permission: "read",
+      authorityMode: "no-authority",
+      model: runtime.model,
+      effort: runtime.effort,
+      timeoutConfig: { connectMs: 30_000, idleMs: 45_000, totalMs: 90_000 },
+      outputLimitBytes: 256 * 1024,
+    });
+  }
+  return parsePurposeProjection(raw);
+}
+
+function writePurposeRepairCopy(root, projection) {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "agentlas-purpose-repair-"));
+  fs.cpSync(path.resolve(root), tempRoot, { recursive: true, dereference: false });
+  const metadataDir = path.join(tempRoot, ".agentlas");
+  fs.mkdirSync(metadataDir, { recursive: true });
+  const routingPath = path.join(metadataDir, "routing-card.json");
+  let routing = {};
+  try { routing = JSON.parse(fs.readFileSync(routingPath, "utf8")); } catch { /* construct it */ }
+  const id = String(routing.id || path.basename(root))
+    .normalize("NFKC").toLowerCase().replace(/[^a-z0-9._/-]+/g, "-").replace(/^-|-$/g, "") || "agent";
+  const card = {
+    ...routing,
+    schemaVersion: "routing-card/2.0",
+    id,
+    type: routing.type === "team" || routing.type === "plugin" ? routing.type : "agent",
+    name: projection.titleEn,
+    summary: projection.summary.slice(0, 240),
+    capabilities: projection.capabilities,
+    routing_status: "routing_ready",
+    workforce: {
+      ...(routing.workforce && typeof routing.workforce === "object" && !Array.isArray(routing.workforce)
+        ? routing.workforce
+        : {}),
+      roles: projection.roles,
+      communities: projection.communities,
+      skills: projection.skills,
+      knowledge: projection.knowledge,
+      languages: [],
+      modalities: [],
+    },
+  };
+  fs.writeFileSync(routingPath, `${JSON.stringify(card, null, 2)}\n`, "utf8");
+  const agentCardPath = path.join(metadataDir, "agent-card.json");
+  let agentCard = {};
+  try { agentCard = JSON.parse(fs.readFileSync(agentCardPath, "utf8")); } catch { /* construct it */ }
+  agentCard = {
+    ...agentCard,
+    name: agentCard.name || projection.titleEn,
+    summary: projection.summary,
+    localized: {
+      ...(agentCard.localized && typeof agentCard.localized === "object" ? agentCard.localized : {}),
+      titleEn: projection.titleEn,
+      titleKo: projection.titleKo,
+      descriptionEn: projection.summary,
+      descriptionKo: projection.descriptionKo,
+    },
+  };
+  fs.writeFileSync(agentCardPath, `${JSON.stringify(agentCard, null, 2)}\n`, "utf8");
+  return tempRoot;
+}
 
 function parseCloudFlags(args) {
   const flags = { _: [] };
@@ -102,7 +251,9 @@ const CLOUD_HELP = [
   "                                      save owner-private in Agent Cloud (default upload)",
   "  publish <path> [--dry-run] [--slug name]",
   "                                      explicitly publish to the public Agentlas Hub",
+  "  --purpose \"ordinary explanation\"     repair a missing purpose through your connected model",
   "  package <path> [--json] [--visibility private-link|marketplace]",
+  "  --overwrite                         서버에 더 새 버전이 있어도 지금 폴더 내용으로 덮어쓰기",
   "                                      package only; defaults to private-save checks",
   "  list [--json]                       list packages in your private Agent Cloud",
   "  restore <slug> [--json]             restore an owned Cloud package on this machine",
@@ -237,12 +388,30 @@ async function runCloud(ctx, args) {
   if (!root) { ctx.err(`usage: agentlas cloud ${sub} <path>`); return 1; }
   const visibility = cloudVisibilityForAction(sub, flags);
   const dryRun = sub === "package" || Boolean(flags["dry-run"]);
-  const result = await packageCloudAgent(ctx.db(), root, {
+  const packageOptions = {
     slug: typeof flags.slug === "string" ? flags.slug : undefined,
     visibility,
     llmReview: Boolean(flags["llm-review"]),
+    overwriteRemote: Boolean(flags.overwrite),
     dryRun,
-  });
+  };
+  let result = await packageCloudAgent(ctx.db(), root, packageOptions);
+  if (sub === "publish" && result.status === "blocked" && purposeRepairNeeded(result) && !flags.json) {
+    const answer = await askPurpose(ctx, flags);
+    if (answer) {
+      const projection = await projectPurposeWithConnectedModel(ctx, answer, path.basename(path.resolve(root)));
+      const repairedRoot = writePurposeRepairCopy(root, projection);
+      try {
+        result = await packageCloudAgent(ctx.db(), repairedRoot, packageOptions);
+      } finally {
+        fs.rmSync(repairedRoot, { recursive: true, force: true });
+      }
+    } else {
+      ctx.err(ctx.lang === "ko"
+        ? `업로드를 완성하려면 답이 필요합니다. 다시 실행할 때 --purpose "평소 말로 설명"을 붙이세요.`
+        : `This upload needs one answer. Retry with --purpose "your ordinary explanation".`);
+    }
+  }
   if (flags.json) {
     ctx.out(JSON.stringify(result, null, 2));
     return (sub === "save" || sub === "publish") && result.status === "blocked" ? 1 : 0;
@@ -267,6 +436,8 @@ module.exports = {
   cloudVisibilityFlag,
   cloudVisibilityForAction,
   cloudActionForTopLevelUpload,
+  purposeRepairNeeded,
+  parsePurposeProjection,
   printCloudPackageResult,
   runCloud,
   runUpload,

package/engine/cloud-assets/package.cjs

@@ -33,10 +33,12 @@ const {
   cloudPortablePathConflict,
   cloudPackageHashVersion,
   cloudHashPackage,
+  normalizeCloudAssetDescriptor,
 } = require("../hub/install.cjs");
 const { SECRET_PATTERNS } = require("../agentlas-secret-patterns.cjs");
 const { userDataDir } = require("../core/paths.cjs");
 const state = require("./state.cjs");
+const { cargoSearchAgents } = require("./cargo.cjs");
 const cas = require("./cas.cjs");
 
 const CLOUD_TEXT_EXTS = new Set([".cfg", ".cjs", ".conf", ".config", ".css", ".csv", ".env", ".html", ".ini", ".js", ".json", ".jsonl", ".md", ".mjs", ".properties", ".ps1", ".psd1", ".psm1", ".py", ".sh", ".toml", ".ts", ".tsx", ".txt", ".xml", ".yaml", ".yml"]);
@@ -575,6 +577,7 @@ function cloudRoutingCardProblem(card) {
   if (card.type !== "agent" && card.type !== "team" && card.type !== "plugin") return "type must be agent, team, or plugin";
   if (typeof card.name !== "string" || !card.name.trim()) return "name must be a non-empty string";
   if (typeof card.summary !== "string" || !card.summary.trim()) return "summary must be a non-empty string";
+  if (card.summary.length > 240) return "summary must be at most 240 characters";
   if (!Array.isArray(card.capabilities) || card.capabilities.length === 0) return "capabilities must be a non-empty array";
   for (const capability of card.capabilities) {
     if (typeof capability !== "string" || !CLOUD_ROUTING_CARD_CAPABILITY_RE.test(capability)) {
@@ -584,6 +587,33 @@ function cloudRoutingCardProblem(card) {
   if (typeof card.routing_status !== "string" || !CLOUD_ROUTING_CARD_STATUSES.has(card.routing_status)) {
     return "routing_status must be draft, searchable, candidate, routing_ready, or trusted";
   }
+  const workforce = card.workforce;
+  if (!workforce || typeof workforce !== "object" || Array.isArray(workforce)) {
+    return "workforce must be a complete semantic resume";
+  }
+  const semanticLists = [
+    ["communities", /^community:[a-z0-9][a-z0-9-]*$/, 1, 5],
+    ["roles", /^role:[a-z0-9][a-z0-9-]*$/, 0, 4],
+    ["skills", /^skill:[a-z0-9][a-z0-9-]*$/, 1, 12],
+    ["knowledge", /^knowledge:[a-z0-9][a-z0-9-]*$/, 0, 256],
+  ];
+  for (const [field, pattern, minimum, maximum] of semanticLists) {
+    const values = workforce[field];
+    if (!Array.isArray(values) || values.length < minimum || values.length > maximum) {
+      return `workforce.${field} must contain ${minimum}-${maximum} English semantic IDs`;
+    }
+    if (new Set(values).size !== values.length ||
+        values.some((value) => typeof value !== "string" || !pattern.test(value))) {
+      return `workforce.${field} contains an invalid or duplicate semantic ID`;
+    }
+  }
+  for (const field of ["languages", "modalities"]) {
+    const values = workforce[field];
+    if (!Array.isArray(values) || new Set(values).size !== values.length ||
+        values.some((value) => typeof value !== "string")) {
+      return `workforce.${field} must be a unique string array`;
+    }
+  }
   return null;
 }
 
@@ -748,6 +778,28 @@ function cloudSecuritySummary(findings) {
 
 // ── 메인: 패키지(+등록) ──
 
+/**
+ * 이 계정이 소유한 자산의 현재 리비전을 서버에서 조회한다.
+ * 로컬 관측 기록이 전혀 없는 새 PC/새 클론에서 갱신을 가능하게 하는 유일한 경로다.
+ * 소유자 세션이 없거나 자산이 없으면 null — 조용한 폴백은 만들지 않는다.
+ */
+async function lookupOwnedCloudDescriptor(slug, scope) {
+  let response;
+  try {
+    response = await cargoSearchAgents({ q: slug, limit: 20 });
+  } catch {
+    return null;
+  }
+  const rows = Array.isArray(response && response.results) ? response.results : [];
+  const row = rows.find((item) => item && item.slug === slug && item.scope === scope);
+  if (!row) return null;
+  try {
+    return normalizeCloudAssetDescriptor(row, "owner cloud search result");
+  } catch {
+    return null;
+  }
+}
+
 async function packageCloudAgent(db, root, opts = {}) {
   const requestedRoot = path.resolve(root);
   let st;
@@ -796,7 +848,7 @@ async function packageCloudAgent(db, root, opts = {}) {
   const name = cloudReadName(snapshot, path.basename(rootPath));
   const slug = cloudSlug(opts.slug || cloudReadStableSlug(snapshot) || name || path.basename(rootPath));
   const scope = cas.cloudScopeForVisibility(visibility);
-  const baseDescriptor = state.cloudBaseDescriptorForSource(scan.localPackageMarker, rootPath, slug, scope);
+  let baseDescriptor = state.cloudBaseDescriptorForSource(scan.localPackageMarker, rootPath, slug, scope);
   const packageHashVersion = CLOUD_PACKAGE_HASH_V2;
   const packageHash = cloudHashPackage(scan.included, packageHashVersion);
   const manifest = {
@@ -844,6 +896,30 @@ async function packageCloudAgent(db, root, opts = {}) {
   let registration = null;
   let status = blocked ? "blocked" : opts.dryRun ? "dry-run" : "ready";
   if (!blocked && !opts.dryRun) {
+    // 자산의 정체성은 (로그인 계정, slug)다 — 어느 폴더에서 올리는지는 중요하지 않다.
+    // 쓰기 전에 서버가 들고 있는 내 자산의 현재 버전을 조회해서:
+    //   · 이 폴더에 기록이 없으면(새 PC, 새 클론) 그 버전을 기준으로 업데이트한다.
+    //   · 이 폴더 기록이 서버보다 오래됐으면(다른 곳에서 먼저 올림) 덮어쓰기 전에 멈춘다.
+    // 이것은 412 뒤의 자동 재시도가 아니라 쓰기 전 refresh다. 등록 자체는 여전히
+    // 조회한 정확한 리비전에 대한 조건부 쓰기(If-Match)라 경합은 서버가 막는다.
+    const remote = await lookupOwnedCloudDescriptor(slug, scope);
+    if (!baseDescriptor && remote) {
+      baseDescriptor = state.rememberCloudAssetDescriptor(remote, { sourceRoot: rootPath });
+    } else if (baseDescriptor && remote && baseDescriptor.revision !== remote.revision) {
+      if (opts.overwriteRemote) {
+        baseDescriptor = state.rememberCloudAssetDescriptor(remote, { sourceRoot: rootPath });
+      } else {
+        const error = new Error(
+          `업로드하지 않았습니다. "${slug}"에 더 새 버전이 있습니다 (${remote.updatedAt || "시각 미상"}에 다른 곳에서 저장됨).\n` +
+          `  지금 폴더 내용으로 그 버전을 덮어쓰려면: --overwrite\n` +
+          `  먼저 그 버전을 받아서 비교하려면:      agentlas cloud restore ${slug}\n` +
+          `  (서버 cloudId ${remote.cloudId} · revision ${remote.revision})`,
+        );
+        error.code = "cloud_agent_revision_conflict";
+        error.current = remote;
+        throw error;
+      }
+    }
     registration = await cas.registerCloudAgent(manifest, bundlePath, review, visibility, { baseDescriptor });
     let descriptor;
     try {

package/engine/cloud-assets/state.cjs

@@ -174,6 +174,39 @@ function cloudBaseDescriptorFromMarker(marker, slug, scope) {
  * 톰스톤에 걸린 마커 디스크립터는 무시(삭제 후 재저장은 새 생성이어야 한다).
  * 둘 다 있으면 같은 cloudId에서 더 최신 관측을 채택한다.
  */
+/**
+ * 이 slug/scope의 관측된 리비전은 있는데, 이 소스 루트에는 아직 연결되지 않은
+ * 경우를 돌려준다.
+ *
+ * 이 구분이 없으면 base 조회가 null을 돌려주고, 호출부는 그것을 "새 자산"으로
+ * 읽어 create precondition을 보낸다. 서버에는 자산이 멀쩡히 존재하므로 412로
+ * 거절되고, 사용자는 "다른 PC에서 변경됨 / restore 하세요"라는 엉뚱한 안내를
+ * 받는다. restore는 디스크립터를 설치 경로에 묶으므로 소스 루트에서 발행하는
+ * 한 영원히 해소되지 않는다. 모름을 그럴듯한 값으로 메꾸지 않기 위한 분기다.
+ */
+function cloudUnboundDescriptorForSource(rootPath, slug, scope) {
+  const state = readCloudAssetState();
+  const entry = state.assets[`${scope}:${slug}`];
+  if (!entry) return null;
+  return entry.sourceRoots.includes(path.resolve(rootPath)) ? null : entry.descriptor;
+}
+
+/** 이 소스 루트를 이미 관측된 클라우드 자산에 명시적으로 연결한다. */
+function bindCloudAssetSourceRoot(rootPath, slug, scope) {
+  const state = readCloudAssetState();
+  const key = `${scope}:${slug}`;
+  const entry = state.assets[key];
+  if (!entry) throw new Error(`No observed Cloud revision for ${key} to bind.`);
+  const normalizedRoot = path.resolve(rootPath);
+  const roots = [...new Set([...entry.sourceRoots, normalizedRoot])].slice(0, 32);
+  state.assets[key] = { descriptor: entry.descriptor, sourceRoots: roots };
+  state.deletedBases = state.deletedBases.filter(
+    (item) => !(item.rootPath === normalizedRoot && item.slug === slug && item.scope === scope),
+  );
+  writeCloudAssetState(state);
+  return entry.descriptor;
+}
+
 function cloudBaseDescriptorForSource(marker, rootPath, slug, scope) {
   const state = readCloudAssetState();
   const normalizedRoot = path.resolve(rootPath);
@@ -263,6 +296,8 @@ module.exports = {
   cloudMarkerDescriptors,
   cloudBaseDescriptorFromMarker,
   cloudBaseDescriptorForSource,
+  cloudUnboundDescriptorForSource,
+  bindCloudAssetSourceRoot,
   writeCloudSourceMarker,
   readCloudSourceMarker,
 };

package/engine/commands/plugin.cjs

@@ -12,6 +12,7 @@ const {
   installPluginMcpRows,
   listHubPlugins,
 } = require("../hub/plugins.cjs");
+const { terminalProjectCandidateCli, initializedAgentlasProjectPathCli } = require("../project/state.cjs");
 
 async function pluginAdd(ctx, slug) {
   if (!slug) {
@@ -90,12 +91,90 @@ async function pluginList(ctx) {
   return 0;
 }
 
+async function pluginListWithProject(ctx, projectPath) {
+  const root = terminalProjectCandidateCli(projectPath);
+  if (!root) {
+    ctx.err(`project path is invalid or not safe: ${projectPath}`);
+    return 1;
+  }
+  if (!initializedAgentlasProjectPathCli(root)) {
+    ctx.err("project is not initialized for plugin listing. Run `agentlas project init` in that folder first.");
+    return 1;
+  }
+  ctx.out("Scope: global Hub plugin catalog (project compatibility and local installation state are not evaluated).");
+  return pluginList(ctx);
+}
+
+function parsePluginListFlags(args) {
+  const flags = {
+    global: false,
+    project: null,
+    errors: [],
+    positionals: [],
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--global") {
+      flags.global = true;
+      continue;
+    }
+    if (arg === "--project") {
+      const next = args[i + 1];
+      if (!next || next.startsWith("-")) {
+        flags.errors.push("usage: agentlas plugin list --project <path>");
+        return flags;
+      }
+      flags.project = next;
+      i += 1;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      flags.errors.push("usage: agentlas plugin list [--global | --project <path>]");
+      return flags;
+    }
+    if (arg.startsWith("--")) {
+      flags.errors.push(`unknown flag: ${arg}`);
+      return flags;
+    }
+    flags.positionals.push(arg);
+  }
+  if (flags.project && flags.global) {
+    flags.errors.push("cannot use --project and --global together");
+  }
+  if (flags.positionals.length > 0) {
+    flags.errors.push("usage: agentlas plugin list [--global | --project <path>]");
+  }
+  return flags;
+}
+
+async function runPluginList(ctx, args) {
+  const flags = parsePluginListFlags(args);
+  if (flags.errors.length) {
+    ctx.err(flags.errors[0]);
+    return 1;
+  }
+  if (flags.project) return pluginListWithProject(ctx, flags.project);
+  return pluginList(ctx);
+}
+
 function run(ctx, args) {
   const action = args[0];
-  if (action === "add") return pluginAdd(ctx, args[1]);
-  if (action === "list" || !action) return pluginList(ctx);
+  if (action === "add") {
+    if (args.length !== 2) {
+      ctx.err("usage: agentlas plugin add <slug>   (run agentlas plugin list first)");
+      return 1;
+    }
+    return pluginAdd(ctx, args[1]);
+  }
+  if (action === "list" || !action) {
+    const rest = action === "list" ? args.slice(1) : [];
+    return runPluginList(ctx, rest);
+  }
   ctx.err("usage: agentlas plugin add <slug> | agentlas plugin list");
   return 1;
 }
 
-module.exports = { run };
+module.exports = {
+  run,
+  parsePluginListFlags,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlas",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "Agentlas agent terminal — chat with your installed AI agents and teams from the terminal, Claude Code style. Standalone: no desktop app required.",
   "bin": {
     "agentlas": "bin/agentlas.cjs"