fix: codex-sm linear sync, db enhancements, and hook installer updates

- Remove LINEAR_API_KEY env guard from codex-sm exit sync — let sync
  command handle auth detection (supports env var, .env, and OAuth)
- Enhance sqlite-adapter and frame-database with additional queries
- Update linear sync engine with improved error handling
- Update hook installer with new capabilities
- Bump dependencies in package.json

Author: StackMemory Bot (CLI)

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "Project-scoped memory for AI coding tools. Durable context across sessions with MCP integration, frames, smart retrieval, Claude Code skills, and automatic hooks.",
   "engines": {
     "node": ">=20.0.0",
@@ -121,6 +121,7 @@
     "daemon:status": "node dist/cli/index.js daemon status",
     "sync:start": "node scripts/background-sync-manager.js",
     "sync:setup": "./scripts/setup-background-sync.sh",
+    "eval:cord": "npx tsx scripts/evals/cord-vs-flat-eval.ts",
     "prepare": "echo 'Prepare step completed'",
     "verify:dist": "node scripts/verify-dist.cjs",
     "test:smoke-db": "bash scripts/smoke-init-db.sh",

package.json

@@ -81,6 +81,14 @@ try {
       commandPrefix: 'node',
       required: true,
     },
+    {
+      scriptName: 'cord-trace.js',
+      eventType: 'PostToolUse',
+      matcher: 'mcp__.*__cord_(spawn|fork|complete|ask|tree)',
+      timeout: 2,
+      commandPrefix: 'node',
+      required: true,
+    },
   ];
 
   const DEAD_HOOKS = ['sms-response-handler.js'];

scripts/install-claude-hooks-auto.js

@@ -407,16 +407,15 @@ class CodexSM {
         exitCode: code,
       });
 
-      // Sync Linear on exit if configured
-      if (process.env['LINEAR_API_KEY']) {
-        try {
-          execSync('stackmemory linear sync', {
-            stdio: 'ignore',
-            timeout: 10000,
-          });
-        } catch {
-          // Non-fatal: don't block exit
-        }
+      // Sync Linear on exit — let sync command handle auth detection
+      // (supports API key env var, .env files, and OAuth tokens)
+      try {
+        execSync('stackmemory linear sync', {
+          stdio: 'ignore',
+          timeout: 10000,
+        });
+      } catch {
+        // Non-fatal: don't block exit
       }
 
       if (this.config.tracingEnabled) {

src/cli/codex-sm.ts

@@ -387,6 +387,16 @@ export function registerLinearCommands(parent: Command) {
             config
           );
 
+          if (!syncEngine.isConfigured) {
+            console.log(
+              chalk.gray(
+                'ℹ Linear API key not configured — skipping sync. Set LINEAR_API_KEY or run "stackmemory linear setup".'
+              )
+            );
+            db.close();
+            return;
+          }
+
           console.log(chalk.yellow('🔄 Syncing with Linear...'));
 
           if (options.dryRun) {

src/cli/commands/linear.ts

@@ -227,6 +227,32 @@ export class FrameDatabase {
         INSERT OR IGNORE INTO schema_version (version) VALUES (1);
       `);
 
+      // Cord task orchestration table (dependency DAG for multi-agent coordination)
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS cord_tasks (
+          task_id TEXT PRIMARY KEY,
+          parent_id TEXT,
+          project_id TEXT NOT NULL,
+          run_id TEXT NOT NULL,
+          goal TEXT NOT NULL,
+          prompt TEXT NOT NULL DEFAULT '',
+          result TEXT,
+          status TEXT NOT NULL DEFAULT 'pending'
+            CHECK (status IN ('pending','active','completed','blocked','asked')),
+          context_mode TEXT NOT NULL DEFAULT 'spawn'
+            CHECK (context_mode IN ('spawn','fork','ask')),
+          blocked_by TEXT NOT NULL DEFAULT '[]',
+          depth INTEGER NOT NULL DEFAULT 0,
+          created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+          completed_at INTEGER,
+          FOREIGN KEY (parent_id) REFERENCES cord_tasks(task_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_cord_tasks_project ON cord_tasks(project_id);
+        CREATE INDEX IF NOT EXISTS idx_cord_tasks_parent ON cord_tasks(parent_id);
+        CREATE INDEX IF NOT EXISTS idx_cord_tasks_status ON cord_tasks(status);
+        CREATE INDEX IF NOT EXISTS idx_cord_tasks_project_status ON cord_tasks(project_id, status);
+      `);
+
       logger.info('Frame database schema initialized');
     } catch (error: unknown) {
       throw new DatabaseError(

src/core/context/frame-database.ts

@@ -1927,6 +1927,122 @@ export class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     return Buffer.from(JSON.stringify(data, null, 2));
   }
 
+  /**
+   * Get recent frames from other run_ids within the same project.
+   * Used by team tools to read cross-agent context.
+   */
+  async getRecentFramesExcludingRun(
+    projectId: string,
+    excludeRunId: string,
+    opts?: { limit?: number; since?: number; types?: string[] }
+  ): Promise<Array<Frame & { anchors: Anchor[] }>> {
+    if (!this.db)
+      throw new DatabaseError(
+        'Database not connected',
+        ErrorCode.DB_CONNECTION_FAILED
+      );
+
+    const limit = opts?.limit ?? 10;
+    const params: any[] = [projectId, excludeRunId];
+    let whereExtra = '';
+
+    if (opts?.since) {
+      whereExtra += ' AND created_at > ?';
+      params.push(Math.floor(opts.since / 1000));
+    }
+
+    if (opts?.types && opts.types.length > 0) {
+      const placeholders = opts.types.map(() => '?').join(',');
+      whereExtra += ` AND type IN (${placeholders})`;
+      params.push(...opts.types);
+    }
+
+    params.push(limit);
+
+    const rows = this.db
+      .prepare(
+        `SELECT * FROM frames
+         WHERE project_id = ? AND run_id != ?${whereExtra}
+         ORDER BY created_at DESC
+         LIMIT ?`
+      )
+      .all(...params) as FrameRow[];
+
+    // Batch-fetch anchors for all returned frames
+    const frameIds = rows.map((r) => r.frame_id);
+    const anchorsByFrame = new Map<string, Anchor[]>();
+
+    if (frameIds.length > 0) {
+      const placeholders = frameIds.map(() => '?').join(',');
+      const anchorRows = this.db
+        .prepare(
+          `SELECT * FROM anchors WHERE frame_id IN (${placeholders})
+           ORDER BY priority DESC, created_at ASC`
+        )
+        .all(...frameIds) as AnchorRow[];
+
+      for (const row of anchorRows) {
+        const list = anchorsByFrame.get(row.frame_id) || [];
+        list.push({ ...row, metadata: JSON.parse(row.metadata || '{}') });
+        anchorsByFrame.set(row.frame_id, list);
+      }
+    }
+
+    return rows.map((row) => ({
+      ...row,
+      inputs: JSON.parse(row.inputs || '{}'),
+      outputs: JSON.parse(row.outputs || '{}'),
+      digest_json: JSON.parse(row.digest_json || '{}'),
+      anchors: anchorsByFrame.get(row.frame_id) || [],
+    }));
+  }
+
+  /**
+   * Get anchors explicitly shared for team visibility.
+   * Finds anchors where metadata contains `"shared":true`.
+   */
+  async getSharedAnchors(
+    projectId: string,
+    opts?: { limit?: number; since?: number }
+  ): Promise<Array<Anchor & { frame_name?: string; run_id?: string }>> {
+    if (!this.db)
+      throw new DatabaseError(
+        'Database not connected',
+        ErrorCode.DB_CONNECTION_FAILED
+      );
+
+    const limit = opts?.limit ?? 20;
+    const params: any[] = [projectId];
+    let whereExtra = '';
+
+    if (opts?.since) {
+      whereExtra += ' AND a.created_at > ?';
+      params.push(Math.floor(opts.since / 1000));
+    }
+
+    params.push(limit);
+
+    const rows = this.db
+      .prepare(
+        `SELECT a.*, f.name as frame_name, f.run_id
+         FROM anchors a
+         JOIN frames f ON a.frame_id = f.frame_id
+         WHERE f.project_id = ?
+           AND a.metadata LIKE '%"shared":true%'${whereExtra}
+         ORDER BY a.priority DESC, a.created_at DESC
+         LIMIT ?`
+      )
+      .all(...params) as (AnchorRow & {
+      frame_name?: string;
+      run_id?: string;
+    })[];
+
+    return rows.map((row) => ({
+      ...row,
+      metadata: JSON.parse(row.metadata || '{}'),
+    }));
+  }
+
   async importData(
     data: Buffer,
     format: 'json' | 'parquet' | 'csv',

src/core/database/sqlite-adapter.ts

@@ -58,12 +58,13 @@ export interface TaskMapping {
 
 export class LinearSyncEngine {
   private taskStore: LinearTaskManager;
-  private linearClient: LinearClient;
+  private linearClient!: LinearClient;
   private authManager: LinearAuthManager;
   private config: SyncConfig;
   private mappings: Map<string, TaskMapping> = new Map();
   private projectRoot: string;
   private mappingsPath: string;
+  private _isConfigured: boolean = true;
 
   constructor(
     taskStore: LinearTaskManager,
@@ -93,10 +94,9 @@ export class LinearSyncEngine {
       // Fall back to OAuth tokens
       const tokens = this.authManager.loadTokens();
       if (!tokens) {
-        throw new IntegrationError(
-          'Linear API key or authentication tokens not found. Set LINEAR_API_KEY environment variable or run "stackmemory linear setup" first.',
-          ErrorCode.LINEAR_SYNC_FAILED
-        );
+        logger.info('Linear API key not configured — skipping Linear sync');
+        this._isConfigured = false;
+        return;
       }
 
       this.linearClient = new LinearClient({
@@ -112,6 +112,13 @@ export class LinearSyncEngine {
     this.loadMappings();
   }
 
+  /**
+   * Check if Linear credentials are available
+   */
+  get isConfigured(): boolean {
+    return this._isConfigured;
+  }
+
   /**
    * Update sync configuration
    */
@@ -123,6 +130,15 @@ export class LinearSyncEngine {
    * Perform bi-directional sync
    */
   async sync(): Promise<SyncResult> {
+    if (!this._isConfigured) {
+      return {
+        success: true,
+        synced: { toLinear: 0, fromLinear: 0, updated: 0 },
+        conflicts: [],
+        errors: [],
+      };
+    }
+
     if (!this.config.enabled) {
       return {
         success: false,

src/integrations/linear/sync.ts

@@ -18,13 +18,14 @@ const HOOKS_DIR = path.join(os.homedir(), '.claude', 'hooks');
 
 describe('hook-installer', () => {
   describe('CANONICAL_HOOKS', () => {
-    it('defines all 4 core hooks', () => {
-      expect(CANONICAL_HOOKS).toHaveLength(4);
+    it('defines all 5 core hooks', () => {
+      expect(CANONICAL_HOOKS).toHaveLength(5);
       const names = CANONICAL_HOOKS.map((h) => h.scriptName);
       expect(names).toContain('session-rescue.sh');
       expect(names).toContain('stop-checkpoint.js');
       expect(names).toContain('chime-on-stop.sh');
       expect(names).toContain('auto-checkpoint.js');
+      expect(names).toContain('cord-trace.js');
     });
 
     it('all core hooks are required', () => {

src/utils/__tests__/hook-installer.test.ts

@@ -54,6 +54,14 @@ export const CANONICAL_HOOKS: HookEntry[] = [
     commandPrefix: 'node',
     required: true,
   },
+  {
+    scriptName: 'cord-trace.js',
+    eventType: 'PostToolUse',
+    matcher: 'mcp__.*__cord_(spawn|fork|complete|ask|tree)',
+    timeout: 2,
+    commandPrefix: 'node',
+    required: true,
+  },
 ];
 
 /** Script names that should be removed from settings (dead/deprecated hooks) */