@c4a/daemon 0.4.12-alpha.3 → 0.4.12-beta.14

package/index.js

@@ -8794,6 +8794,7 @@ var RelationType;
   RelationType2["Triggers"] = "TRIGGERS";
   RelationType2["References"] = "REFERENCES";
   RelationType2["Corresponds"] = "CORRESPONDS";
+  RelationType2["Mentions"] = "MENTIONS";
 })(RelationType ||= {});
 var AtomField;
 ((AtomField2) => {
@@ -8811,6 +8812,7 @@ var AtomField;
   AtomField2["Constraints"] = "constraints";
   AtomField2["Comparisons"] = "comparisons";
   AtomField2["Boundaries"] = "boundaries";
+  AtomField2["Claims"] = "claims";
 })(AtomField ||= {});
 var Kind;
 ((Kind2) => {
@@ -8823,6 +8825,161 @@ var Perspective;
   Perspective2["Business"] = "business";
   Perspective2["Technical"] = "technical";
 })(Perspective ||= {});
+// ../core/src/types/edgeSyncRules.ts
+var EDGE_SYNC_RULES = [
+  {
+    field: "container_id",
+    sourceEntityType: "component" /* Component */,
+    edgeType: "CONTAINS" /* Contains */,
+    direction: "reverse",
+    writeGraph: true
+  },
+  {
+    field: "system_id",
+    sourceEntityType: "container" /* Container */,
+    edgeType: "CONTAINS" /* Contains */,
+    direction: "reverse",
+    writeGraph: true
+  },
+  {
+    field: "ref_sor",
+    sourceEntityType: "sor" /* SoR */,
+    edgeType: "REFERENCES" /* References */,
+    direction: "forward",
+    writeGraph: true
+  },
+  {
+    field: "product_refs",
+    sourceEntityType: "epic" /* Epic */,
+    edgeType: "REFERENCES" /* References */,
+    direction: "forward",
+    writeGraph: true
+  },
+  {
+    field: "atoms.entities.ref",
+    sourceEntityType: "any",
+    edgeType: "MENTIONS" /* Mentions */,
+    direction: "forward",
+    writeGraph: true
+  },
+  {
+    field: "atoms.behaviors.ref",
+    sourceEntityType: "any",
+    edgeType: "MENTIONS" /* Mentions */,
+    direction: "forward",
+    writeGraph: true
+  },
+  {
+    field: "product_id",
+    sourceEntityType: "sor" /* SoR */,
+    edgeType: null,
+    direction: "forward",
+    writeGraph: false
+  },
+  {
+    field: "process_id",
+    sourceEntityType: "sor" /* SoR */,
+    edgeType: "PRODUCES" /* Produces */,
+    direction: "reverse",
+    writeGraph: true
+  }
+];
+// ../core/src/types/serverConfig.ts
+var DEFAULT_SERVER_CONFIG = {
+  server: {
+    port: 5100,
+    host: "::"
+  },
+  git_hosts: [],
+  daemon_scheduler: {
+    enabled: true,
+    host: "localhost",
+    port: 5110,
+    workspace: "./data/daemon-workspace",
+    max_daemons: 20
+  },
+  doc_db: {
+    provider: "sqlite",
+    sqlite: {
+      path: "./data/c4a.db"
+    },
+    mongodb: {
+      uri: "mongodb://localhost:27017/c4a?directConnection=true",
+      database: "c4a"
+    }
+  },
+  graph_db: {
+    provider: "neo4j",
+    neo4j: {
+      uri: "bolt://localhost:7687",
+      username: "neo4j",
+      password: ""
+    },
+    nebulagraph: {
+      uri: "localhost:9669",
+      username: "root",
+      password: "nebula",
+      space: "c4a"
+    },
+    duckdb: {
+      path: "./data/c4a-graph.duckdb"
+    }
+  },
+  vector_db: {
+    provider: "lancedb",
+    collection_prefix: "c4a_",
+    qdrant: {
+      url: "http://localhost:6333",
+      api_key: ""
+    },
+    milvus: {
+      address: "localhost:19530"
+    },
+    lancedb: {
+      path: "./data/lancedb"
+    }
+  },
+  llm: {
+    provider: "openai",
+    openai: {
+      api_key: "",
+      base_url: "",
+      default_model: "gpt-5.3-codex"
+    },
+    anthropic: {
+      api_key: "",
+      base_url: "",
+      default_model: "claude-opus-4-6"
+    },
+    google: {
+      api_key: "",
+      base_url: "",
+      default_model: "gemini-3-pro-preview"
+    }
+  },
+  embedding: {
+    provider: "huggingface",
+    huggingface: {
+      model_id: "Xenova/all-MiniLM-L6-v2",
+      dtype: "q8",
+      cache_dir: "./models/embedding"
+    },
+    xenova: {
+      model_id: "Xenova/bge-m3",
+      dtype: "q8",
+      cache_dir: "./models/embedding"
+    },
+    openai: {
+      api_key: "",
+      base_url: "",
+      model_id: "text-embedding-3-small"
+    },
+    google: {
+      api_key: "",
+      model_id: "text-embedding-004"
+    }
+  }
+};
 // ../core/src/types/daemon.ts
 var CODE_PACKAGE_FILES = new Set([
   "package.json",
@@ -12867,7 +13024,7 @@ var atomFieldSchema = exports_external.enum(Object.values(AtomField));
 var kindSchema = exports_external.enum(Object.values(Kind));
 var scopeSchema = exports_external.literal("project");
 var perspectiveSchema = exports_external.enum(Object.values(Perspective));
-var confidenceSchema = exports_external.object({
+var extractionConfidenceSchema = exports_external.object({
   structural: exports_external.number().min(0).max(1),
   semantic: exports_external.number().min(0).max(1)
 });
@@ -12875,13 +13032,29 @@ var metadataSchema = exports_external.object({
   created_at: exports_external.string().datetime(),
   updated_at: exports_external.string().datetime(),
   version_tag: exports_external.string().optional(),
-  confidence: confidenceSchema.optional()
-});
+  extraction_confidence: extractionConfidenceSchema.optional(),
+  confidence: exports_external.number().min(0).max(1).optional(),
+  aliases: exports_external.array(exports_external.string()).optional(),
+  rank: exports_external.number().optional(),
+  community_id: exports_external.string().optional(),
+  community_level: exports_external.number().optional()
+});
+var entityRefPointerSchema = exports_external.string().regex(/^ref:entity:.+$/, "must be a ref pointer in format ref:entity:<id>");
+var sourceRefSpanSchema = exports_external.object({
+  start: exports_external.number().int().min(1),
+  end: exports_external.number().int().min(1)
+});
+var sourceRefSchema = exports_external.object({
+  ref: exports_external.string(),
+  span: sourceRefSpanSchema.optional()
+});
+var sourceRefsSchema = exports_external.array(sourceRefSchema).optional();
 // ../core/src/schemas/atomsSchema.ts
 var confidenceAtomSchema = exports_external.number().min(0).max(1).optional();
 var entityAtomSchema = exports_external.object({
   name: exports_external.string(),
   kind: kindSchema.optional(),
+  ref: exports_external.string().optional(),
   confidence: confidenceAtomSchema
 });
 var relationAtomSchema = exports_external.object({
@@ -12895,6 +13068,8 @@ var behaviorAtomSchema = exports_external.object({
   name: exports_external.string(),
   signature: exports_external.string().optional(),
   description: exports_external.string().optional(),
+  performed_by: exports_external.array(exports_external.string()).optional(),
+  ref: exports_external.string().optional(),
   confidence: confidenceAtomSchema
 });
 var attributeAtomSchema = exports_external.object({
@@ -12935,6 +13110,7 @@ var decisionPhaseSchema = exports_external.object({
   rationale: exports_external.string().optional()
 });
 var decisionAtomSchema = exports_external.object({
+  name: exports_external.string().optional(),
   description: exports_external.string(),
   rationale: exports_external.string(),
   alternatives: exports_external.array(exports_external.string()).optional(),
@@ -12957,9 +13133,9 @@ var metricAtomSchema = exports_external.object({
 });
 var roleAtomSchema = exports_external.object({
   name: exports_external.string(),
-  kind: exports_external.enum(["internal", "external"]),
+  kind: exports_external.enum(["human", "team", "persona"]),
   performs: exports_external.array(exports_external.string()).optional(),
-  confidence: confidenceAtomSchema
+  description: exports_external.string().optional()
 });
 var constraintAtomSchema = exports_external.object({
   description: exports_external.string(),
@@ -12990,6 +13166,16 @@ var comparisonAtomSchema = exports_external.object({
   decision_ref: exports_external.string().optional(),
   confidence: confidenceAtomSchema
 });
+var claimAtomSchema = exports_external.object({
+  claim_type: exports_external.string(),
+  description: exports_external.string(),
+  status: exports_external.enum(["active", "deprecated", "proposed"]),
+  valid_from: exports_external.string(),
+  valid_until: exports_external.string().optional(),
+  session_ref: exports_external.string().optional(),
+  changed_by: exports_external.string(),
+  confidence: confidenceAtomSchema
+});
 var dataAtomsSchema = exports_external.object({
   entities: exports_external.array(entityAtomSchema).optional(),
   relations: exports_external.array(relationAtomSchema).optional(),
@@ -13004,31 +13190,115 @@ var dataAtomsSchema = exports_external.object({
   roles: exports_external.array(roleAtomSchema).optional(),
   constraints: exports_external.array(constraintAtomSchema).optional(),
   comparisons: exports_external.array(comparisonAtomSchema).optional(),
-  boundaries: exports_external.array(boundaryAtomSchema).optional()
+  boundaries: exports_external.array(boundaryAtomSchema).optional(),
+  claims: exports_external.array(claimAtomSchema).optional()
 }).superRefine((atoms2, ctx) => {
-  if (!atoms2.transitions || atoms2.transitions.length === 0) {
-    return;
-  }
   const stateValues = new Set;
+  const stateNames = new Set;
   for (const state of atoms2.states ?? []) {
+    stateNames.add(state.name);
     for (const value of state.values) {
       stateValues.add(value);
     }
   }
-  for (const transition of atoms2.transitions) {
-    if (!stateValues.has(transition.from)) {
-      ctx.addIssue({
-        code: exports_external.ZodIssueCode.custom,
-        path: ["transitions"],
-        message: `transition.from references unknown state: ${transition.from}`
-      });
+  const behaviorNames = new Set;
+  for (const behavior of atoms2.behaviors ?? []) {
+    behaviorNames.add(behavior.name);
+  }
+  const roleNames = new Set;
+  for (const role of atoms2.roles ?? []) {
+    roleNames.add(role.name);
+  }
+  const eventNames = new Set;
+  for (const event of atoms2.events ?? []) {
+    eventNames.add(event.name);
+  }
+  const metricNames = new Set;
+  for (const metric of atoms2.metrics ?? []) {
+    metricNames.add(metric.name);
+  }
+  if (atoms2.transitions && atoms2.transitions.length > 0) {
+    for (const transition of atoms2.transitions) {
+      if (!stateValues.has(transition.from)) {
+        ctx.addIssue({
+          code: exports_external.ZodIssueCode.custom,
+          path: ["transitions"],
+          message: `transition.from references unknown state: ${transition.from}`
+        });
+      }
+      if (!stateValues.has(transition.to)) {
+        ctx.addIssue({
+          code: exports_external.ZodIssueCode.custom,
+          path: ["transitions"],
+          message: `transition.to references unknown state: ${transition.to}`
+        });
+      }
+      const hasEvents = eventNames.size > 0;
+      const hasBehaviors = behaviorNames.size > 0;
+      if (hasEvents || hasBehaviors) {
+        const triggerMatchesEvent = hasEvents && eventNames.has(transition.trigger);
+        const triggerMatchesBehavior = hasBehaviors && behaviorNames.has(transition.trigger);
+        if (!triggerMatchesEvent && !triggerMatchesBehavior) {
+          ctx.addIssue({
+            code: exports_external.ZodIssueCode.custom,
+            path: ["transitions"],
+            message: `transition.trigger references unknown event/behavior: ${transition.trigger}`
+          });
+        }
+      }
     }
-    if (!stateValues.has(transition.to)) {
-      ctx.addIssue({
-        code: exports_external.ZodIssueCode.custom,
-        path: ["transitions"],
-        message: `transition.to references unknown state: ${transition.to}`
-      });
+  }
+  if (atoms2.roles && atoms2.roles.length > 0) {
+    for (const [index, role] of atoms2.roles.entries()) {
+      for (const perform of role.performs ?? []) {
+        if (!behaviorNames.has(perform)) {
+          ctx.addIssue({
+            code: exports_external.ZodIssueCode.custom,
+            path: ["roles", index, "performs"],
+            message: `role.performs references unknown behavior: ${perform}`
+          });
+        }
+      }
+    }
+  }
+  if (atoms2.behaviors && atoms2.behaviors.length > 0) {
+    for (const [index, behavior] of atoms2.behaviors.entries()) {
+      for (const performer of behavior.performed_by ?? []) {
+        if (!roleNames.has(performer)) {
+          ctx.addIssue({
+            code: exports_external.ZodIssueCode.custom,
+            path: ["behaviors", index, "performed_by"],
+            message: `behavior.performed_by references unknown role: ${performer}`
+          });
+        }
+      }
+    }
+  }
+  if (atoms2.rules && atoms2.rules.length > 0) {
+    const allowedDependsOn = new Set([...stateNames, ...metricNames]);
+    for (const [index, rule] of atoms2.rules.entries()) {
+      for (const dependency of rule.depends_on ?? []) {
+        if (!allowedDependsOn.has(dependency)) {
+          ctx.addIssue({
+            code: exports_external.ZodIssueCode.custom,
+            path: ["rules", index, "depends_on"],
+            message: `rule.depends_on references unknown state/metric: ${dependency}`
+          });
+        }
+      }
+    }
+  }
+  if (atoms2.events && atoms2.events.length > 0) {
+    for (const [index, event] of atoms2.events.entries()) {
+      for (const behaviorName of event.trigger_for ?? []) {
+        if (!behaviorNames.has(behaviorName)) {
+          ctx.addIssue({
+            code: exports_external.ZodIssueCode.custom,
+            path: ["events", index, "trigger_for"],
+            message: `event.trigger_for references unknown behavior: ${behaviorName}`
+          });
+        }
+      }
     }
   }
 });
@@ -13044,7 +13314,8 @@ var atomsWhitelistByEntityType = {
     "states" /* States */,
     "rules" /* Rules */,
     "transitions" /* Transitions */,
-    "events" /* Events */
+    "events" /* Events */,
+    "claims" /* Claims */
   ]),
   ["process" /* Process */]: new Set,
   ["sor" /* SoR */]: new Set([
@@ -13060,7 +13331,8 @@ var atomsWhitelistByEntityType = {
     "metrics" /* Metrics */,
     "roles" /* Roles */,
     "constraints" /* Constraints */,
-    "comparisons" /* Comparisons */
+    "comparisons" /* Comparisons */,
+    "claims" /* Claims */
   ]),
   ["contract" /* Contract */]: new Set,
   ["epic" /* Epic */]: new Set([
@@ -13068,7 +13340,8 @@ var atomsWhitelistByEntityType = {
     "metrics" /* Metrics */,
     "roles" /* Roles */,
     "constraints" /* Constraints */,
-    "comparisons" /* Comparisons */
+    "comparisons" /* Comparisons */,
+    "claims" /* Claims */
   ]),
   ["document" /* Document */]: new Set
 };
@@ -13093,7 +13366,8 @@ var baseEntitySchema = exports_external.object({
   kind: kindSchema,
   scope: scopeSchema,
   perspective: perspectiveSchema,
-  metadata: metadataSchema
+  metadata: metadataSchema,
+  source_refs: sourceRefsSchema
 });
 var productDataSchema = exports_external.object({
   description: exports_external.string().optional(),
@@ -13107,7 +13381,8 @@ var productEntitySchema = baseEntitySchema.extend({
 });
 var systemDataSchema = exports_external.object({
   description: exports_external.string().optional(),
-  corresponds_to: exports_external.string().optional()
+  corresponds_to: exports_external.string().optional(),
+  atoms: exports_external.undefined().optional()
 });
 var systemEntitySchema = baseEntitySchema.extend({
   type: exports_external.literal("system" /* System */),
@@ -13153,9 +13428,10 @@ var sorEntitySchema = baseEntitySchema.extend({
   data: sorDataSchema
 });
 var contractDataSchema = exports_external.object({
-  format: exports_external.enum(["openapi", "asyncapi", "proto"]),
+  format: exports_external.enum(["openapi", "asyncapi", "proto", "graphql", "custom"]),
   spec: exports_external.string(),
-  component_id: exports_external.string().optional()
+  version: exports_external.string().optional(),
+  description: exports_external.string().optional()
 });
 var contractEntitySchema = baseEntitySchema.extend({
   type: exports_external.literal("contract" /* Contract */),
@@ -13163,7 +13439,7 @@ var contractEntitySchema = baseEntitySchema.extend({
 });
 var epicDataSchema = exports_external.object({
   description: exports_external.string().optional(),
-  product_refs: exports_external.array(exports_external.string()).optional(),
+  product_refs: exports_external.array(entityRefPointerSchema).optional(),
   atoms: dataAtomsSchema.optional()
 });
 var epicEntitySchema = baseEntitySchema.extend({
@@ -13239,18 +13515,45 @@ var entitySchema = exports_external.discriminatedUnion("type", [
       });
     }
   }
+  if (entity2.type === "sor" /* SoR */ && entity2.data.atoms) {
+    const { constraints, rules } = entity2.data.atoms;
+    const hasConstraints = Array.isArray(constraints) && constraints.length > 0;
+    const hasRules = Array.isArray(rules) && rules.length > 0;
+    if (!hasConstraints && !hasRules) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["data", "atoms"],
+        message: "SoR must have at least one constraint or rule"
+      });
+    }
+  }
+  if (entity2.type === "epic" /* Epic */ && entity2.data.atoms) {
+    const { decisions } = entity2.data.atoms;
+    const hasDecisions = Array.isArray(decisions) && decisions.length > 0;
+    if (!hasDecisions) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["data", "atoms"],
+        message: "Epic must have at least one decision"
+      });
+    }
+  }
 });
 // ../core/src/schemas/relationSchema.ts
 var relationDataSchema = exports_external.object({
-  description: exports_external.string().optional()
+  description: exports_external.string().optional(),
+  _source: exports_external.literal("field_sync").optional()
 });
 var relationSchema = exports_external.object({
   id: exports_external.string(),
   type: relationTypeSchema,
   from: exports_external.string(),
   to: exports_external.string(),
+  weight: exports_external.number().optional(),
+  confidence: exports_external.number().min(0).max(1).optional(),
   data: relationDataSchema.optional(),
-  metadata: metadataSchema.optional()
+  metadata: metadataSchema.optional(),
+  source_refs: sourceRefsSchema
 });
 // ../core/src/errors/httpStatus.ts
 var ERROR_CODE_HTTP_STATUS = {
@@ -13270,6 +13573,10 @@ var ERROR_CODE_HTTP_STATUS = {
   ["ENTITY_DUPLICATE" /* ENTITY_DUPLICATE */]: 409,
   ["API_UNAUTHORIZED" /* API_UNAUTHORIZED */]: 401,
   ["LLM_AUTH_FAILED" /* LLM_AUTH_FAILED */]: 401,
+  ["AUTH_REQUIRED" /* AUTH_REQUIRED */]: 401,
+  ["AUTH_INVALID_TOKEN" /* AUTH_INVALID_TOKEN */]: 401,
+  ["AUTH_INVALID_API_KEY" /* AUTH_INVALID_API_KEY */]: 401,
+  ["AUTH_RESERVED_NAME" /* AUTH_RESERVED_NAME */]: 400,
   ["API_RATE_LIMITED" /* API_RATE_LIMITED */]: 429,
   ["API_NOT_IMPLEMENTED" /* API_NOT_IMPLEMENTED */]: 501,
   ["BATCH_PARTIAL_FAILURE" /* BATCH_PARTIAL_FAILURE */]: 200,
@@ -13282,29 +13589,135 @@ var ERROR_CODE_HTTP_STATUS = {
   ["PURGE_FAILED" /* PURGE_FAILED */]: 500,
   ["EMBEDDING_NOT_AVAILABLE" /* EMBEDDING_NOT_AVAILABLE */]: 503,
   ["LLM_NOT_AVAILABLE" /* LLM_NOT_AVAILABLE */]: 503,
-  ["UNKNOWN" /* UNKNOWN */]: 500
+  ["AUTH_PROVIDER_ERROR" /* AUTH_PROVIDER_ERROR */]: 502,
+  ["UNKNOWN" /* UNKNOWN */]: 500,
+  ["WORKSPACE_ISOLATION" /* WORKSPACE_ISOLATION */]: 400
 };
 // ../core/src/utils/yaml.ts
 var import_yaml = __toESM(require_dist(), 1);
 // ../core/src/constants.ts
 var DAEMON_HEARTBEAT_INTERVAL = 30000;
+var CLOUD_DAEMON_IDLE_TIMEOUT = 300000;
+// ../core/src/contentTypeRegistry.ts
+var DEFAULT_CONTENT_TYPES = [
+  {
+    id: "markdown",
+    category: "doc",
+    match: { extensions: [".md", ".txt"] },
+    cas: { encoding: "utf8", hashInput: "content" },
+    pipeline: { digest: ["summary", "outline"], extraction: ["entities", "relations"] },
+    display: { icon: "\uD83D\uDCC4", renderer: "text" }
+  },
+  {
+    id: "typescript",
+    category: "code",
+    match: { extensions: [".ts", ".tsx"] },
+    cas: { encoding: "utf8", hashInput: "content" },
+    pipeline: { digest: ["ast", "summary"], extraction: ["entities", "relations"] },
+    display: { icon: "\uD83D\uDCDC", renderer: "code" }
+  },
+  {
+    id: "package",
+    category: "package",
+    match: { filenames: ["package.json", "go.mod", "pyproject.toml", "Cargo.toml", "pom.xml"] },
+    cas: { encoding: "utf8", hashInput: "identity" },
+    pipeline: { digest: ["summary"], extraction: ["entities", "relations"] },
+    display: { icon: "\uD83D\uDCE6", renderer: "package-card" }
+  },
+  {
+    id: "pdf",
+    category: "binary",
+    match: { extensions: [".pdf"] },
+    cas: { encoding: "base64", hashInput: "content" },
+    pipeline: { digest: [], extraction: [] },
+    display: { icon: "\uD83D\uDCD5", renderer: "binary-preview" }
+  },
+  {
+    id: "msword",
+    category: "binary",
+    match: { extensions: [".doc", ".docx"] },
+    cas: { encoding: "base64", hashInput: "content" },
+    pipeline: { digest: [], extraction: [] },
+    display: { icon: "\uD83D\uDCD8", renderer: "binary-preview" }
+  },
+  {
+    id: "mspowerpoint",
+    category: "binary",
+    match: { extensions: [".ppt", ".pptx"] },
+    cas: { encoding: "base64", hashInput: "content" },
+    pipeline: { digest: [], extraction: [] },
+    display: { icon: "\uD83D\uDCD9", renderer: "binary-preview" }
+  }
+];
+var normalizeExtension = (ext) => ext.trim().toLowerCase();
+var normalizeFilename = (name) => name.trim().toLowerCase();
+
+class ContentTypeRegistry {
+  definitions;
+  extensionIndex;
+  filenameIndex;
+  constructor(definitions) {
+    this.definitions = definitions;
+    this.extensionIndex = new Map;
+    this.filenameIndex = new Map;
+    for (const def of definitions) {
+      for (const ext of def.match.extensions ?? []) {
+        this.extensionIndex.set(normalizeExtension(ext), def);
+      }
+      for (const name of def.match.filenames ?? []) {
+        this.filenameIndex.set(normalizeFilename(name), def);
+      }
+    }
+  }
+  resolve(filename) {
+    const baseName = filename.includes("/") ? filename.split("/").pop() ?? filename : filename;
+    const normalized = normalizeFilename(baseName);
+    const byName = this.filenameIndex.get(normalized);
+    if (byName)
+      return byName;
+    const dot = normalized.lastIndexOf(".");
+    if (dot < 0)
+      return null;
+    const ext = normalizeExtension(normalized.slice(dot));
+    return this.extensionIndex.get(ext) ?? null;
+  }
+  getManifestFilenames() {
+    const names = new Set;
+    for (const def of this.definitions) {
+      if (def.category !== "package")
+        continue;
+      for (const name of def.match.filenames ?? []) {
+        names.add(normalizeFilename(name));
+      }
+    }
+    return Array.from(names);
+  }
+  getDefinitions() {
+    return [...this.definitions];
+  }
+}
+var defaultRegistry = new ContentTypeRegistry(DEFAULT_CONTENT_TYPES);
+var DEFAULT_CONTENT_TYPE_DEFINITIONS = DEFAULT_CONTENT_TYPES;
 // ../core/src/fileTypes.ts
-var INDEXABLE_CODE_EXTENSIONS = new Set([".ts", ".tsx"]);
-var INDEXABLE_DOC_EXTENSIONS = new Set([".md"]);
+var collectExtensions = (predicate) => {
+  const extensions = new Set;
+  for (const definition of DEFAULT_CONTENT_TYPE_DEFINITIONS) {
+    if (!predicate(definition))
+      continue;
+    for (const ext of definition.match.extensions ?? []) {
+      extensions.add(ext.toLowerCase());
+    }
+  }
+  return extensions;
+};
+var INDEXABLE_CODE_EXTENSIONS = collectExtensions((definition) => definition.category === "code");
+var INDEXABLE_DOC_EXTENSIONS = collectExtensions((definition) => definition.category === "doc");
 var INDEXABLE_EXTENSIONS = new Set([
   ...INDEXABLE_CODE_EXTENSIONS,
   ...INDEXABLE_DOC_EXTENSIONS
 ]);
-var UPLOAD_ALLOWED_EXTENSIONS = new Set([
-  ".md",
-  ".doc",
-  ".docx",
-  ".pdf",
-  ".ppt",
-  ".pptx",
-  ".txt"
-]);
-var TEXT_EXTENSIONS = new Set([".md", ".txt"]);
+var UPLOAD_ALLOWED_EXTENSIONS = collectExtensions(() => true);
+var TEXT_EXTENSIONS = collectExtensions((definition) => definition.cas.encoding === "utf8");
 var UPLOAD_MAX_FILE_SIZE = 5 * 1024 * 1024;
 // src/handlers/utils.ts
 import path2 from "node:path";
@@ -13385,18 +13798,22 @@ function resolveServerUrl(input) {
   }
   const isLocal = host.startsWith("localhost") || host.startsWith("127.0.0.1") || host.startsWith("0.0.0.0");
   const protocol = isLocal ? "ws" : "wss";
-  const base2 = host.replace(/^localhost/, "127.0.0.1").replace(/\/+$/, "");
+  const base2 = host.replace(/\/+$/, "");
   return `${protocol}://${base2}${WS_DAEMON_PATH}`;
 }
-var parseAllowedPaths = (input) => {
+var parseAllowedPaths = (input, extraPath) => {
   if (!input) {
-    return ["*"];
+    return extraPath ? ["*", extraPath] : ["*"];
   }
   const parts = input.split(",").map((s) => s.trim()).filter(Boolean);
   if (parts.includes("*")) {
-    return ["*"];
+    return extraPath ? ["*", extraPath] : ["*"];
   }
-  return normalizeAllowedPaths(parts);
+  const normalized = normalizeAllowedPaths(parts);
+  if (extraPath && !normalized.includes("*")) {
+    normalized.push(extraPath);
+  }
+  return normalizeAllowedPaths(normalized);
 };
 
 // src/handshake.ts
@@ -13429,8 +13846,8 @@ var readPackageVersion = (packageRoot = getPackageRoot()) => {
   const parsed = JSON.parse(raw);
   return parsed.version ?? "0.0.0";
 };
-var buildHandshakePayload = (allowedPaths) => {
-  const machineId = os.hostname();
+var buildHandshakePayload = (allowedPaths, machineIdOverride) => {
+  const machineId = machineIdOverride?.trim() || os.hostname();
   return {
     machine_id: machineId,
     machine_name: machineId,
@@ -13713,12 +14130,41 @@ var createFsReadFileHandler = (allowedPaths) => async (params) => {
 // src/handlers/fsRepoStatus.ts
 var REPO_STATUS_CACHE_TTL_MS = 1e4;
 var repoStatusCache = new Map;
+var parseForEachRef = (raw) => {
+  const entries = [];
+  for (const line of raw.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    const [name, commit] = line.split(" ");
+    if (name && commit)
+      entries.push({ name, commit });
+  }
+  return entries;
+};
+var parseLogOutput = (raw) => {
+  const entries = [];
+  for (const line of raw.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    const spaceIdx = line.indexOf(" ");
+    if (spaceIdx === -1) {
+      entries.push({ hash: line.trim(), message: "" });
+    } else {
+      entries.push({ hash: line.slice(0, spaceIdx), message: line.slice(spaceIdx + 1) });
+    }
+  }
+  return entries;
+};
 var createFsRepoStatusHandler = (allowedPaths) => async (params) => {
   const now = Date.now();
   const payload = params;
   const rawPath = ensureString(payload?.path, "path");
+  const requestedBranch = typeof payload?.branch === "string" ? payload.branch : "";
   const targetPath = assertAllowedPath(rawPath, allowedPaths);
-  const cached = repoStatusCache.get(targetPath);
+  const cacheKey = `${targetPath}:${requestedBranch}`;
+  const cached = repoStatusCache.get(cacheKey);
   if (cached?.value && cached.expiresAt > now) {
     return cached.value;
   }
@@ -13726,26 +14172,36 @@ var createFsRepoStatusHandler = (allowedPaths) => async (params) => {
     return cached.inflight;
   }
   const inflight = (async () => {
-    const [branch, headHash, remoteResult] = await Promise.all([
+    const [branch, headHash, remoteResult, branchesRaw, tagsRaw] = await Promise.all([
       runGit(["rev-parse", "--abbrev-ref", "HEAD"], targetPath),
       runGit(["rev-parse", "HEAD"], targetPath),
-      tryRunGit(["config", "--get", "remote.origin.url"], targetPath)
+      tryRunGit(["config", "--get", "remote.origin.url"], targetPath),
+      runGit(["for-each-ref", "refs/heads", "--format=%(refname:short) %(objectname)"], targetPath),
+      runGit(["for-each-ref", "refs/tags", "--format=%(refname:short) %(objectname)"], targetPath)
     ]);
     const dirtyResult = await tryRunGit(["diff-index", "--quiet", "HEAD", "--"], targetPath);
+    const branches = parseForEachRef(branchesRaw);
+    const tags = parseForEachRef(tagsRaw);
+    const logBranch = requestedBranch || branch;
+    const logResult = await tryRunGit(["log", logBranch, "--format=%H %s", "-n", "30"], targetPath);
+    const commits = logResult.ok ? parseLogOutput(logResult.stdout) : [];
     return {
       branch,
       head_hash: headHash,
       is_dirty: !dirtyResult.ok,
-      remote_url: remoteResult.ok ? remoteResult.stdout.trim() || undefined : undefined
+      remote_url: remoteResult.ok ? remoteResult.stdout.trim() || undefined : undefined,
+      branches,
+      tags,
+      commits
     };
   })();
-  repoStatusCache.set(targetPath, { expiresAt: now + REPO_STATUS_CACHE_TTL_MS, inflight });
+  repoStatusCache.set(cacheKey, { expiresAt: now + REPO_STATUS_CACHE_TTL_MS, inflight });
   try {
     const value = await inflight;
-    repoStatusCache.set(targetPath, { expiresAt: Date.now() + REPO_STATUS_CACHE_TTL_MS, value });
+    repoStatusCache.set(cacheKey, { expiresAt: Date.now() + REPO_STATUS_CACHE_TTL_MS, value });
     return value;
   } finally {
-    const entry = repoStatusCache.get(targetPath);
+    const entry = repoStatusCache.get(cacheKey);
     if (entry?.inflight) {
       delete entry.inflight;
     }
@@ -13753,8 +14209,6 @@ var createFsRepoStatusHandler = (allowedPaths) => async (params) => {
 };
 
 // src/handlers/fsRepoScan.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import path7 from "node:path";
 var DEFAULT_INCLUDE2 = ["manifests", "docs"];
 var matchesFilter2 = (filePath, include) => {
   if (include.includes("*"))
@@ -13816,8 +14270,7 @@ var createFsRepoScanHandler = (allowedPaths) => async (params) => {
     if (!fileName || !CODE_PACKAGE_FILES.has(fileName.toLowerCase()))
       continue;
     try {
-      const fullPath = path7.join(targetPath, file.path);
-      const content = await readFile4(fullPath, "utf-8");
+      const content = await runGit(["show", `${hash2}:${file.path}`], targetPath);
       if (!isValidManifest(file.path, content))
         continue;
       manifests.push({ path: file.path, content });
@@ -13858,8 +14311,362 @@ var createFsRepoTreeHandler = (allowedPaths) => async (params) => {
   return { files };
 };
 
+// src/handlers/configSetAuth.ts
+import { chmod, mkdir, writeFile } from "node:fs/promises";
+
+// src/handlers/vcsUtils.ts
+import { execFile as execFile2, spawn } from "node:child_process";
+import path7 from "node:path";
+var stripAuthFromUrl = (rawUrl) => {
+  try {
+    const parsed = new URL(rawUrl);
+    if (parsed.username || parsed.password) {
+      parsed.username = "";
+      parsed.password = "";
+    }
+    return `${parsed.protocol}//${parsed.host}${parsed.pathname}`;
+  } catch {
+    return rawUrl;
+  }
+};
+var gitConfigPath = (workDir) => path7.join(workDir, ".git-daemon.config");
+var gitCredentialsPath = (workDir) => path7.join(workDir, ".git-daemon.credentials");
+var createGitEnv = (workDir) => {
+  const base2 = {
+    ...process.env,
+    LANG: "C",
+    LC_ALL: "C",
+    GIT_TERMINAL_PROMPT: "0"
+  };
+  if (!workDir)
+    return base2;
+  return { ...base2, GIT_CONFIG_GLOBAL: gitConfigPath(workDir) };
+};
+var parseGitVersion = (raw) => {
+  const match = raw.match(/git version (\d+)\.(\d+)\.(\d+)/i);
+  if (!match)
+    return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3])
+  };
+};
+var isGitVersionAtLeast = (version, target) => {
+  if (version.major !== target.major)
+    return version.major > target.major;
+  if (version.minor !== target.minor)
+    return version.minor > target.minor;
+  return version.patch >= target.patch;
+};
+var getGitVersion = async (env) => new Promise((resolve) => {
+  execFile2("git", ["--version"], { env }, (error, stdout) => {
+    if (error) {
+      console.log(`[getGitVersion] execFile error: ${error.message}`);
+      return resolve(null);
+    }
+    const raw = stdout.trim();
+    const parsed = parseGitVersion(raw);
+    console.log(`[getGitVersion] raw="${raw}" parsed=${JSON.stringify(parsed)}`);
+    resolve(parsed);
+  });
+});
+var EXEC_GIT_MAX_BUFFER = 20 * 1024 * 1024;
+var execGit = async (args, options = {}) => new Promise((resolve, reject) => {
+  execFile2("git", args, { cwd: options.cwd, env: options.env, maxBuffer: EXEC_GIT_MAX_BUFFER }, (error, stdout, stderr) => {
+    if (error) {
+      reject(error);
+      return;
+    }
+    resolve({ stdout: stdout.toString(), stderr: stderr.toString() });
+  });
+});
+var GIT_PROGRESS_RE = /(Enumerating|Receiving|Counting|Compressing|Resolving) (?:objects|deltas):\s+(\d+)%\s*(?:\([^)]*\))?/;
+var GIT_PHASE_WEIGHTS = {
+  Enumerating: [0, 3],
+  Counting: [3, 6],
+  Compressing: [6, 10],
+  Receiving: [10, 90],
+  Resolving: [90, 100]
+};
+var weightedPercent = (phase, rawPercent) => {
+  const [start, end] = GIT_PHASE_WEIGHTS[phase] ?? [0, 100];
+  return Math.round(start + rawPercent / 100 * (end - start));
+};
+var runGitWithProgress = async (args, options) => new Promise((resolve, reject) => {
+  console.log(`[runGitWithProgress] spawn: git ${args.join(" ")}`);
+  const child = spawn("git", args, {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let lastWeighted = null;
+  let stderrBuf = "";
+  child.stderr.on("data", (chunk) => {
+    const text = chunk.toString();
+    stderrBuf += text;
+    const lines = stderrBuf.split(/[\r\n]+/);
+    stderrBuf = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed)
+        continue;
+      options.onStderr?.(trimmed);
+      const match = trimmed.match(GIT_PROGRESS_RE);
+      if (match) {
+        const phase = match[1];
+        const raw = Number(match[2]);
+        if (!Number.isNaN(raw)) {
+          const weighted = weightedPercent(phase, raw);
+          if (weighted !== lastWeighted) {
+            lastWeighted = weighted;
+            options.onProgress?.({ percent: weighted, label: trimmed });
+          }
+        }
+      }
+    }
+  });
+  child.on("error", (error) => {
+    reject(error);
+  });
+  child.on("close", (code) => {
+    if (stderrBuf.trim()) {
+      options.onStderr?.(stderrBuf.trim());
+    }
+    if (code === 0) {
+      console.log("[runGitWithProgress] finished successfully");
+      resolve();
+    } else {
+      reject(new Error(`git ${args.join(" ")} failed with code ${code}`));
+    }
+  });
+});
+
+// src/handlers/configSetAuth.ts
+var ensureWorkDir = (workDir) => {
+  if (!workDir) {
+    throw new RpcError(JSON_RPC_ERROR_CODES.INVALID_PARAMS, "Work dir not configured");
+  }
+  return workDir;
+};
+var formatCredentialLines = (hosts) => hosts.map((host) => {
+  const authUser = host.auth_user ?? "oauth2";
+  return `https://${authUser}:${host.token}@${host.host}`;
+});
+var createConfigSetAuthHandler = (workDir) => async (params, _context) => {
+  const payload = params;
+  const hosts = Array.isArray(payload?.hosts) ? payload.hosts : null;
+  if (!hosts) {
+    throw new RpcError(JSON_RPC_ERROR_CODES.INVALID_PARAMS, "Invalid hosts");
+  }
+  for (const entry of hosts) {
+    ensureString(entry?.host, "host");
+    ensureString(entry?.auth_user, "auth_user");
+    ensureString(entry?.token, "token");
+  }
+  const rootDir = ensureWorkDir(workDir);
+  await mkdir(rootDir, { recursive: true });
+  const configPath = gitConfigPath(rootDir);
+  const credentialsPath = gitCredentialsPath(rootDir);
+  const configContent = `[credential]
+  helper = store --file ${credentialsPath}
+`;
+  await writeFile(configPath, configContent, "utf-8");
+  const lines = formatCredentialLines(hosts);
+  await writeFile(credentialsPath, `${lines.join(`
+`)}
+`, "utf-8");
+  await chmod(credentialsPath, 384);
+  return { ok: true };
+};
+
+// src/handlers/vcsClone.ts
+import { mkdir as mkdir2, rename, rm } from "node:fs/promises";
+import path8 from "node:path";
+var MIN_GIT_VERSION = { major: 2, minor: 5, patch: 0 };
+var ensureWorkDir2 = (workDir) => {
+  if (!workDir) {
+    throw new RpcError(JSON_RPC_ERROR_CODES.INVALID_PARAMS, "Work dir not configured");
+  }
+  return workDir;
+};
+var extractRepoNameFromUrl = (url) => {
+  try {
+    const parsed = new URL(url);
+    const name = parsed.pathname.split("/").filter(Boolean).pop() ?? "repo";
+    return name.replace(/\.git$/i, "") || "repo";
+  } catch {
+    return "repo";
+  }
+};
+var getRepoDir = (workDir, repoName) => path8.join(workDir, "repos", repoName);
+var notifyProgress = (notify, percent, detail) => {
+  if (!notify)
+    return;
+  const payload = {
+    stage: "cloning",
+    label: "cloning",
+    percent,
+    ...detail ? { detail } : {}
+  };
+  notify("task/progress", payload);
+};
+var getRemoteUrl = async (repoDir, env) => {
+  try {
+    const result = await execGit(["-C", repoDir, "config", "--get", "remote.origin.url"], { env });
+    const url = result.stdout.trim();
+    return url.length > 0 ? url : null;
+  } catch {
+    return null;
+  }
+};
+var getHeadCommit = async (repoDir, env) => {
+  const result = await execGit(["-C", repoDir, "rev-parse", "HEAD"], { env });
+  return result.stdout.trim();
+};
+var createVcsCloneHandler = (workDir) => async (params, context) => {
+  const payload = params;
+  const url = ensureString(payload?.url, "url");
+  const ref = payload?.ref;
+  const commit = payload?.commit;
+  if (ref !== undefined) {
+    ensureString(ref, "ref");
+  }
+  if (commit !== undefined) {
+    ensureString(commit, "commit");
+  }
+  const rootDir = ensureWorkDir2(workDir);
+  const repoName = payload?.repo_name || extractRepoNameFromUrl(url);
+  const repoDir = getRepoDir(rootDir, repoName);
+  const env = createGitEnv(rootDir);
+  if (commit) {
+    const version = await getGitVersion(env);
+    console.log(`[vcs/clone] git version check: parsed=${JSON.stringify(version)}, env.PATH=${env?.PATH ?? process.env.PATH}`);
+    if (!version || !isGitVersionAtLeast(version, MIN_GIT_VERSION)) {
+      const current = version ? `${version.major}.${version.minor}.${version.patch}` : "unknown";
+      throw new RpcError(JSON_RPC_ERROR_CODES.INVALID_PARAMS, `Commit hash checkout requires Git 2.5+, current version: ${current}. Please use branch/tag selection instead.`);
+    }
+  }
+  await mkdir2(rootDir, { recursive: true });
+  const legacyRepoDir = path8.join(rootDir, "repo");
+  const hasNewDir = await execGit(["-C", repoDir, "rev-parse", "--git-dir"], { env }).then(() => true).catch(() => false);
+  if (!hasNewDir) {
+    const hasLegacy = await execGit(["-C", legacyRepoDir, "rev-parse", "--git-dir"], { env }).then(() => true).catch(() => false);
+    if (hasLegacy) {
+      const legacyRemote = await getRemoteUrl(legacyRepoDir, env);
+      if (legacyRemote && stripAuthFromUrl(legacyRemote) === stripAuthFromUrl(url)) {
+        await mkdir2(path8.dirname(repoDir), { recursive: true });
+        await rename(legacyRepoDir, repoDir);
+      }
+    }
+  }
+  const hasGitDir = await execGit(["-C", repoDir, "rev-parse", "--git-dir"], { env }).then(() => true).catch(() => false);
+  if (hasGitDir) {
+    const remoteUrl = await getRemoteUrl(repoDir, env);
+    if (remoteUrl && stripAuthFromUrl(remoteUrl) === stripAuthFromUrl(url)) {
+      if (commit) {
+        await runGitWithProgress(["-C", repoDir, "fetch", "--depth=1", "--progress", "origin", commit], {
+          env,
+          onProgress: ({ percent, label }) => notifyProgress(context?.notify, percent, label),
+          onStderr: (text) => console.log(`[vcs/clone] git: ${text}`)
+        });
+        await execGit(["-C", repoDir, "checkout", commit], { env });
+      } else {
+        const refToUse = ref ?? "HEAD";
+        await runGitWithProgress(["-C", repoDir, "fetch", "--depth=1", "--progress", "origin", refToUse], {
+          env,
+          onProgress: ({ percent, label }) => notifyProgress(context?.notify, percent, label),
+          onStderr: (text) => console.log(`[vcs/clone] git: ${text}`)
+        });
+        await execGit(["-C", repoDir, "checkout", "FETCH_HEAD"], { env });
+      }
+    } else {
+      await rm(repoDir, { recursive: true, force: true });
+    }
+  }
+  const repoExists = await execGit(["-C", repoDir, "rev-parse", "--git-dir"], { env }).then(() => true).catch(() => false);
+  if (!repoExists) {
+    if (commit) {
+      await mkdir2(repoDir, { recursive: true });
+      await execGit(["-C", repoDir, "init"], { env });
+      await execGit(["-C", repoDir, "remote", "add", "origin", url], { env });
+      await runGitWithProgress(["-C", repoDir, "fetch", "--depth=1", "--progress", "origin", commit], {
+        env,
+        onProgress: ({ percent, label }) => notifyProgress(context?.notify, percent, label),
+        onStderr: (text) => console.log(`[vcs/clone] git: ${text}`)
+      });
+      await execGit(["-C", repoDir, "checkout", commit], { env });
+    } else if (ref) {
+      await runGitWithProgress(["clone", "--depth=1", "--branch", ref, "--progress", url, repoDir], {
+        env,
+        onProgress: ({ percent, label }) => notifyProgress(context?.notify, percent, label),
+        onStderr: (text) => console.log(`[vcs/clone] git: ${text}`)
+      });
+    } else {
+      await runGitWithProgress(["clone", "--depth=1", "--progress", url, repoDir], {
+        env,
+        onProgress: ({ percent, label }) => notifyProgress(context?.notify, percent, label),
+        onStderr: (text) => console.log(`[vcs/clone] git: ${text}`)
+      });
+    }
+  }
+  const commitHash = await getHeadCommit(repoDir, env);
+  return { path: repoDir, commit_hash: commitHash };
+};
+
+// src/handlers/vcsRefs.ts
+var parseLsRemoteOutput = (raw) => {
+  const entries = [];
+  const lines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  for (const line of lines) {
+    if (line.startsWith("ref: "))
+      continue;
+    const [commit, ref] = line.split(/\s+/);
+    if (!commit || !ref)
+      continue;
+    if (ref.endsWith("^{}"))
+      continue;
+    entries.push({ name: ref, commit });
+  }
+  return entries;
+};
+var extractDefaultBranch = (raw) => {
+  const line = raw.split(/\r?\n/).find((item) => item.startsWith("ref: "));
+  if (!line)
+    return null;
+  const match = line.match(/^ref: refs\/heads\/(.+?)\s+HEAD/);
+  return match?.[1] ?? null;
+};
+var splitRefs = (entries) => {
+  const branches = [];
+  const tags = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith("refs/heads/")) {
+      branches.push({ name: entry.name.replace("refs/heads/", ""), commit: entry.commit });
+    } else if (entry.name.startsWith("refs/tags/")) {
+      tags.push({ name: entry.name.replace("refs/tags/", ""), commit: entry.commit });
+    }
+  }
+  return { branches, tags };
+};
+var createVcsRefsHandler = (workDir) => async (params, _context) => {
+  const payload = params;
+  const url = ensureString(payload?.url, "url");
+  const env = createGitEnv(workDir);
+  try {
+    const out = await execGit(["ls-remote", "--symref", url, "HEAD", "refs/heads/*", "refs/tags/*"], { env });
+    const defaultBranch = extractDefaultBranch(out.stdout) ?? "HEAD";
+    const parsed = parseLsRemoteOutput(out.stdout);
+    const { branches, tags } = splitRefs(parsed);
+    return { branches, tags, default: defaultBranch };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to list refs";
+    throw new RpcError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, message);
+  }
+};
+
 // src/handlers/index.ts
-var createFsHandlers = (allowedPaths) => ({
+var createDaemonHandlers = (allowedPaths, workDir) => ({
   "fs/listTree": createFsListTreeHandler(allowedPaths),
   "fs/dirScan": createFsDirScanHandler(allowedPaths),
   "fs/exists": createFsExistsHandler(allowedPaths),
@@ -13869,7 +14676,10 @@ var createFsHandlers = (allowedPaths) => ({
   "fs/repoStatus": createFsRepoStatusHandler(allowedPaths),
   "fs/commitExists": createFsCommitExistsHandler(allowedPaths),
   "fs/repoTree": createFsRepoTreeHandler(allowedPaths),
-  "fs/repoScan": createFsRepoScanHandler(allowedPaths)
+  "fs/repoScan": createFsRepoScanHandler(allowedPaths),
+  "config/setAuth": createConfigSetAuthHandler(workDir),
+  "vcs/clone": createVcsCloneHandler(workDir),
+  "vcs/refs": createVcsRefsHandler(workDir)
 });
 
 // src/rpcHandler.ts
@@ -13889,8 +14699,10 @@ var buildError = (code, message, data) => ({
 
 class RpcHandler {
   handlers;
-  constructor(handlers) {
+  context;
+  constructor(handlers, context = {}) {
     this.handlers = new Map(Object.entries(handlers));
+    this.context = context;
   }
   async handleMessage(raw) {
     let payload;
@@ -13929,7 +14741,7 @@ class RpcHandler {
       };
     }
     try {
-      const result = await handler(request.params);
+      const result = await handler(request.params, this.context);
       if (request.id === undefined) {
         return null;
       }
@@ -13962,6 +14774,7 @@ class WebSocketClient {
   onError;
   reconnectMinDelayMs;
   reconnectMaxDelayMs;
+  maxReconnectAttempts;
   socket = null;
   shouldReconnect = true;
   reconnectAttempt = 0;
@@ -13975,6 +14788,7 @@ class WebSocketClient {
     this.onError = options.onError;
     this.reconnectMinDelayMs = options.reconnectMinDelayMs ?? 1000;
     this.reconnectMaxDelayMs = options.reconnectMaxDelayMs ?? 30000;
+    this.maxReconnectAttempts = options.maxReconnectAttempts ?? 64;
   }
   connect() {
     this.shouldReconnect = true;
@@ -14086,6 +14900,11 @@ class WebSocketClient {
     this.socket.send(JSON.stringify(response));
   }
   scheduleReconnect() {
+    if (this.maxReconnectAttempts > 0 && this.reconnectAttempt >= this.maxReconnectAttempts) {
+      console.error(`[WebSocketClient] Max reconnect attempts (${this.maxReconnectAttempts}) reached, giving up`);
+      this.shouldReconnect = false;
+      return;
+    }
     const delay = Math.min(this.reconnectMaxDelayMs, this.reconnectMinDelayMs * 2 ** this.reconnectAttempt);
     this.reconnectAttempt += 1;
     setTimeout(() => {
@@ -14105,7 +14924,7 @@ class WebSocketClient {
 
 // src/index.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import { join, dirname } from "node:path";
+import { join, dirname, resolve } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function readVersion() {
   try {
@@ -14121,13 +14940,24 @@ function readVersion() {
   return "unknown";
 }
 var program2 = new Command;
-program2.name("c4a-daemon").description("C4A daemon for local filesystem access").version(readVersion(), "-V, --version").option("--server <host>", "Server host (e.g. localhost:5100, example.com/prefix)", DEFAULT_SERVER_HOST).option("--allow <paths>", "Comma-separated allowed paths (default: all directories)").parse(process.argv);
+program2.name("c4a-daemon").description("C4A daemon for local filesystem access").version(readVersion(), "-V, --version").option("--server <host>", "Server host (e.g. localhost:5100, example.com/prefix)", DEFAULT_SERVER_HOST).option("--allow <paths>", "Comma-separated allowed paths (default: all directories)").option("--machine-id <id>", "Override daemon machine id (default: hostname)").option("--work-dir <dir>", "Working directory for daemon operations").parse(process.argv);
 var options = program2.opts();
 var serverUrl = resolveServerUrl(options.server);
-var allowedPaths = parseAllowedPaths(options.allow);
+var resolvedWorkDir = options.workDir ? resolve(options.workDir) : undefined;
+var allowedPaths = parseAllowedPaths(options.allow, resolvedWorkDir);
 console.log(`Server:  ${serverUrl}`);
 console.log(`Allowed: ${allowedPaths.join(", ")}`);
-var rpcHandler = new RpcHandler(createFsHandlers(allowedPaths));
+if (resolvedWorkDir) {
+  console.log(`WorkDir: ${resolvedWorkDir}`);
+}
+var client;
+var rpcHandler = new RpcHandler(createDaemonHandlers(allowedPaths, resolvedWorkDir), {
+  notify: (method, params) => {
+    try {
+      client.sendNotification(method, params);
+    } catch {}
+  }
+});
 var heartbeatTimer = null;
 var stopHeartbeat = () => {
   if (heartbeatTimer) {
@@ -14135,18 +14965,18 @@ var stopHeartbeat = () => {
     heartbeatTimer = null;
   }
 };
-var startHeartbeat = (client, machineId) => {
+var startHeartbeat = (client2, machineId) => {
   stopHeartbeat();
   heartbeatTimer = setInterval(() => {
-    client.sendNotification("daemon/heartbeat", { machine_id: machineId, timestamp: Date.now() });
+    client2.sendNotification("daemon/heartbeat", { machine_id: machineId, timestamp: Date.now() });
   }, DAEMON_HEARTBEAT_INTERVAL);
 };
-var client = new WebSocketClient({
+client = new WebSocketClient({
   url: serverUrl,
   onRequest: (request) => rpcHandler.handleRequest(request),
   onOpen: async () => {
     try {
-      const handshakePayload = buildHandshakePayload(allowedPaths);
+      const handshakePayload = buildHandshakePayload(allowedPaths, options.machineId);
       const response = await client.sendRpcRequest("daemon/handshake", handshakePayload);
       if ("error" in response) {
         console.error(`Handshake error: ${response.error.message}`);